def solve(specs: List[str], r: Resolve) -> Union[bool, Iterable[str]]:
features = set() # type: Set
for spec in specs:
if conda.config.platform == 'win32' and spec == 'python':
continue
# XXX: This does not work when a spec only contains the name,
# and different versions of the package have different features.
ms = MatchSpec(spec)
for pkg in r.get_pkgs(ms, max_only=False):
fn = pkg.fn
features.update(r.track_features(fn))
for spec in specs:
for pkg in r.get_pkgs(MatchSpec(spec), max_only=False):
fn = pkg.fn
r.update_with_features(fn, features)
print("Solving package specifications: ", end='')
try:
return r.explicit(specs) or r.solve2(specs,
features,
installed=(),
minimal_hint=False,
guess=False,
unsat_only=True)
except RuntimeError:
print('\n')
return False
def execute(args, parser):
import re
import conda.install as install
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
if args.regex:
pat = re.compile(args.regex, re.I)
else:
pat = None
prefix = common.get_prefix(args)
if not args.canonical:
linked = install.linked(prefix)
# XXX: Make this work with more than one platform
platform = args.platform or ''
common.ensure_override_channels_requires_channel(args, dashc=False)
channel_urls = args.channel or ()
index = get_index(channel_urls=channel_urls,
prepend=not args.override_channels,
platform=args.platform)
r = Resolve(index)
for name in sorted(r.groups):
disp_name = name
if pat and pat.search(name) is None:
continue
if args.outdated:
vers_inst = [
dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name
]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
for pkg in sorted(r.get_pkgs(MatchSpec(name))):
dist = pkg.fn[:-8]
if args.canonical:
print(dist)
continue
inst = '*' if dist in linked else ' '
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name,
inst,
pkg.version,
r.index[pkg.fn]['build'],
canonical_channel_name(pkg.channel),
common.disp_features(r.features(pkg.fn)),
))
disp_name = ''
def execute(args, parser):
import re
import conda.install as install
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
if args.regex:
pat = re.compile(args.regex, re.I)
else:
pat = None
prefix = common.get_prefix(args)
if not args.canonical:
linked = install.linked(prefix)
# XXX: Make this work with more than one platform
platform = args.platform or ''
common.ensure_override_channels_requires_channel(args, dashc=False)
channel_urls = args.channel or ()
index = get_index(channel_urls=channel_urls, prepend=not
args.override_channels, platform=args.platform)
r = Resolve(index)
for name in sorted(r.groups):
disp_name = name
if pat and pat.search(name) is None:
continue
if args.outdated:
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
for pkg in sorted(r.get_pkgs(MatchSpec(name))):
dist = pkg.fn[:-8]
if args.canonical:
print(dist)
continue
inst = '*' if dist in linked else ' '
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name, inst,
pkg.version,
r.index[pkg.fn]['build'],
canonical_channel_name(pkg.channel),
common.disp_features(r.features(pkg.fn)),
))
disp_name = ''
def get_package_versions(package):
index = get_index()
r = Resolve(index)
if package in r.groups:
return r.get_pkgs(MatchSpec(package))
else:
return []
def warn_on_old_conda_build(index):
root_linked = linked(cc.root_dir)
vers_inst = [
dist.rsplit('-', 2)[1] for dist in root_linked
if dist.rsplit('-', 2)[0] == 'conda-build'
]
if not len(vers_inst) == 1:
print("WARNING: Could not detect installed version of conda-build",
file=sys.stderr)
return
r = Resolve(index)
try:
pkgs = sorted(r.get_pkgs(MatchSpec('conda-build')))
except NoPackagesFound:
print(
"WARNING: Could not find any versions of conda-build in the channels",
file=sys.stderr)
return
if pkgs[-1].version != vers_inst[0]:
print("""
WARNING: conda-build appears to be out of date. You have version %s but the
latest version is %s. Run
conda update -n root conda-build
to get the latest version.
""" % (vers_inst[0], pkgs[-1].version),
file=sys.stderr)
def warn_on_old_conda_build(index):
root_linked = linked(cc.root_dir)
vers_inst = [dist.rsplit("-", 2)[1] for dist in root_linked if dist.rsplit("-", 2)[0] == "conda-build"]
if not len(vers_inst) == 1:
print("WARNING: Could not detect installed version of conda-build", file=sys.stderr)
return
r = Resolve(index)
try:
pkgs = sorted(r.get_pkgs(MatchSpec("conda-build")))
except NoPackagesFound:
print("WARNING: Could not find any versions of conda-build in the channels", file=sys.stderr)
return
if pkgs[-1].version != vers_inst[0]:
print(
"""
WARNING: conda-build appears to be out of date. You have version %s but the
latest version is %s. Run
conda update -n root conda-build
to get the latest version.
"""
% (vers_inst[0], pkgs[-1].version),
file=sys.stderr,
)
def get_package_versions(package):
index = get_index()
r = Resolve(index)
if package in r.groups:
return r.get_pkgs(MatchSpec(package))
else:
return []
def dependencies_for_env(prefix):
"""
Return an OrderedDict of all packages in the packages in the
given environment and each one's list of dependencies.
The returned items are in toposort order.
"""
# Get all package strings as 'name-version-build'
installed = conda.install.linked(prefix)
exitcode, packages = list_packages(prefix,
installed,
regex=None,
format='canonical',
show_channel_urls=False)
# If present, remove channel prefix (e.g. from 'ilastik::boost=1.55.0=5')
packages = map(lambda p: p.split('::')[-1], packages)
# Replace last two '-' with '='
packages = map(lambda p: p[::-1].replace('-', '=', 2)[::-1], packages)
# Load dependencies into a dict
index = conda.api.get_index()
r = Resolve(index)
deps_dict = {}
for package in packages:
try:
versions = r.get_pkgs(conda.cli.common.arg2spec(package))
except NoPackagesFound:
print("Skipping " + package, file=sys.stderr)
else:
for pkg in sorted(versions):
deps_dict[pkg.name] = []
for dep in pkg.info['depends']:
deps_dict[pkg.name].append(dep.split(' ')[0])
# If a package's dependencies have been updated recently on the server,
# there may be entries in the deps list that aren't actually present in our environment.
# In that case, we just omit that dependency.
for pkg_name, deps in deps_dict.items():
to_remove = []
for dep in deps:
if dep not in deps_dict:
to_remove.append(dep)
for dep in to_remove:
deps_dict[pkg_name].remove(dep)
# Convenience: Return dict with keys in topologically sorted order
sorted_keys = toposort(deps_dict)
#print('\n'.join(sorted_keys))
deps_dict = collections.OrderedDict(
map(lambda k: (k, deps_dict[k]), sorted_keys))
return deps_dict
def show_pkg_info(name):
from conda.api import get_index
from conda.resolve import Resolve
index = get_index()
r = Resolve(index)
print(name)
if name in r.groups:
for pkg in sorted(r.get_pkgs(name)):
print(' %-15s %15s %s' %
(pkg.version, pkg.build, disp_features(r.features(pkg.fn))))
else:
print(' not available')
def latest_pkg_version(pkg):
'''
:returns: the latest version of the specified conda package available
'''
r = Resolve(get_index())
try:
pkg_list = sorted(r.get_pkgs(MatchSpec(pkg)))
except RuntimeError:
pkg_list = None
if pkg_list:
pkg_version = LooseVersion(pkg_list[-1].version)
else:
pkg_version = None
return pkg_version
def solve(specs: List[str], r: Resolve) -> Union[bool, Iterable[str]]:
features = set() # type: Set
for spec in specs:
if conda.config.platform == 'win32' and spec == 'python':
continue
# XXX: This does not work when a spec only contains the name,
# and different versions of the package have different features.
ms = MatchSpec(spec)
for pkg in r.get_pkgs(ms, max_only=False):
fn = pkg.fn
features.update(r.track_features(fn))
for spec in specs:
for pkg in r.get_pkgs(MatchSpec(spec), max_only=False):
fn = pkg.fn
r.update_with_features(fn, features)
print("Solving package specifications: ", end='')
try:
return r.explicit(specs) or r.solve2(specs, features,
installed=(), minimal_hint=False, guess=False, unsat_only=True)
except RuntimeError:
print('\n')
return False
def latest_pkg_version(pkg):
"""
:returns: the latest version of the specified conda package available
"""
r = Resolve(get_index())
try:
pkg_list = sorted(r.get_pkgs(MatchSpec(pkg)))
except RuntimeError:
pkg_list = None
if pkg_list:
pkg_version = LooseVersion(pkg_list[-1].version)
else:
pkg_version = None
return pkg_version
def show_pkg_info(name):
# import conda.install as install
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
index = get_index()
r = Resolve(index)
print(name)
if name in r.groups:
for pkg in sorted(r.get_pkgs(MatchSpec(name))):
print(
" %-15s %15s %s" % (pkg.version, r.index[pkg.fn]["build"], common.disp_features(r.features(pkg.fn)))
)
else:
print(" not available on channels")
def show_pkg_info(name):
#import conda.install as install
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
index = get_index()
r = Resolve(index)
print(name)
if name in r.groups:
for pkg in sorted(r.get_pkgs(MatchSpec(name))):
print(' %-15s %15s %s' %
(pkg.version, pkg.build,
common.disp_features(r.features(pkg.fn))))
else:
print(' not available')
def show_pkg_info(name):
from conda.api import get_index
from conda.resolve import Resolve
index = get_index()
r = Resolve(index)
print(name)
if name in r.groups:
for pkg in sorted(r.get_pkgs(name)):
print(' %-15s %15s %s' % (
pkg.version,
pkg.build,
common.disp_features(r.features(pkg.fn))))
else:
print(' not available')
def conda_package_exists(pkgname, version=None):
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
pyver = 'py%s' % sys.version[:3].replace('.', '')
index = get_index(use_cache=True)
r = Resolve(index)
try:
pkgs = r.get_pkgs(MatchSpec(pkgname))
except RuntimeError:
return False
exists = False
for pkg in pkgs:
match_pyver = pkg.build.startswith(pyver)
if not match_pyver:
continue
if version and pkg.version != version:
continue
exists = True
break
return exists
def conda_package_exists(pkgname, version=None):
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
pyver = 'py%s' % sys.version[:3].replace('.','')
index = get_index(use_cache = True)
r = Resolve(index)
try:
pkgs = r.get_pkgs(MatchSpec(pkgname))
except RuntimeError:
return False
exists = False
for pkg in pkgs:
match_pyver = pkg.build.startswith(pyver)
if not match_pyver:
continue
if version and pkg.version != version:
continue
exists = True
break
return exists
def execute(args, parser):
import re
import conda.install as install
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
if args.regex:
pat = re.compile(args.regex, re.I)
else:
pat = None
prefix = common.get_prefix(args)
if not args.canonical:
linked = install.linked(prefix)
common.ensure_override_channels_requires_channel(args, dashc=False)
channel_urls = args.channel or ()
index = get_index(channel_urls=channel_urls, prepend=not
args.override_channels)
r = Resolve(index)
for name in sorted(r.groups):
disp_name = name
if pat and pat.search(name) is None:
continue
for pkg in sorted(r.get_pkgs(MatchSpec(name))):
dist = pkg.fn[:-8]
if args.canonical:
print(dist)
continue
inst = '*' if dist in linked else ' '
print('%-25s %s %-15s %15s %s' % (
disp_name, inst,
pkg.version,
r.index[pkg.fn]['build'],
common.disp_features(r.features(pkg.fn))) )
disp_name = ''
def dependencies_for_env( prefix ):
"""
Return an OrderedDict of all packages in the packages in the
given environment and each one's list of dependencies.
The returned items are in toposort order.
"""
# Get all package strings as 'name-version-build'
installed = conda.install.linked(prefix)
exitcode, packages = list_packages(prefix, installed, regex=None, format='canonical', show_channel_urls=False)
# If present, remove channel prefix (e.g. from 'ilastik::boost=1.55.0=5')
packages = map( lambda p: p.split('::')[-1], packages )
# Replace last two '-' with '='
packages = map(lambda p: p[::-1].replace('-', '=', 2)[::-1], packages)
# Load dependencies into a dict
index = conda.api.get_index()
r = Resolve(index)
deps_dict = {}
for package in packages:
try:
versions = r.get_pkgs(conda.cli.common.arg2spec(package))
except NoPackagesFound:
print("Skipping " + package, file=sys.stderr)
else:
for pkg in sorted(versions):
deps_dict[pkg.name] = []
for dep in pkg.info['depends']:
deps_dict[pkg.name].append(dep.split(' ')[0])
# Convenience: Return dict with keys in topologically sorted order
sorted_keys = toposort( deps_dict )
deps_dict = collections.OrderedDict( map(lambda k: (k, deps_dict[k]), sorted_keys ) )
return deps_dict
def install(args, parser, command='install'):
"""
conda install, conda update, and conda create
"""
newenv = command == 'create'
if newenv:
common.ensure_name_or_prefix(args, command)
prefix = common.get_prefix(args, search=not newenv)
if newenv:
check_prefix(prefix)
config.set_pkgs_dirs(prefix)
if command == 'update':
if len(args.packages) == 0:
sys.exit("""Error: no package names supplied
# If you want to update to a newer version of Anaconda, type:
#
# $ conda update --prefix %s anaconda
""" % prefix)
if command == 'update':
linked = ci.linked(prefix)
for name in args.packages:
common.arg2spec(name)
if '=' in name:
sys.exit("Invalid package name: '%s'" % (name))
if name not in set(ci.name_dist(d) for d in linked):
sys.exit("Error: package '%s' is not installed in %s" %
(name, prefix))
if newenv and args.clone:
if args.packages:
sys.exit('Error: did not expect any arguments for --clone')
clone(args.clone, prefix)
touch_nonadmin(prefix)
print_activate(args.name if args.name else prefix)
return
if newenv and not args.no_default_packages:
default_packages = config.create_default_packages[:]
# Override defaults if they are specified at the command line
for default_pkg in config.create_default_packages:
if any(pkg.split('=')[0] == default_pkg for pkg in args.packages):
default_packages.remove(default_pkg)
args.packages.extend(default_packages)
common.ensure_override_channels_requires_channel(args)
channel_urls = args.channel or ()
if args.use_local:
from conda.fetch import fetch_index
from conda.utils import url_path
try:
from conda_build import config as build_config
except ImportError:
sys.exit("Error: you need to have 'conda-build' installed"
" to use the --use-local option")
# remove the cache such that a refetch is made,
# this is necessary because we add the local build repo URL
fetch_index.cache = {}
index = get_index([url_path(build_config.croot)],
use_cache=args.use_cache)
else:
index = get_index(channel_urls=channel_urls, prepend=not
args.override_channels,
use_cache=args.use_cache)
# Don't update packages that are already up-to-date
if command == 'update':
r = Resolve(index)
orig_packages = args.packages[:]
for name in orig_packages:
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
build_inst = [dist.rsplit('-', 2)[2].rsplit('.tar.bz2', 1)[0]
for dist in linked
if dist.rsplit('-', 2)[0] == name]
assert len(vers_inst) == 1, name
assert len(build_inst) == 1, name
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
# Shouldn't happen?
continue
# This won't do the right thing for python 2
latest = pkgs[-1]
if latest.version == vers_inst[0] and latest.build == build_inst[0]:
args.packages.remove(name)
if not args.packages:
from conda.cli.main_list import list_packages
regex = '^(%s)$' % '|'.join(orig_packages)
print('# All requested packages already installed.')
list_packages(prefix, regex)
return
# handle tar file containing conda packages
if len(args.packages) == 1:
tar_path = args.packages[0]
if tar_path.endswith('.tar'):
install_tar(prefix, tar_path, verbose=not args.quiet)
return
# handle explicit installs of conda packages
if args.packages and all(s.endswith('.tar.bz2') for s in args.packages):
from conda.misc import install_local_packages
install_local_packages(prefix, args.packages, verbose=not args.quiet)
return
if any(s.endswith('.tar.bz2') for s in args.packages):
sys.exit("cannot mix specifications with conda package filenames")
if args.force:
args.no_deps = True
if args.file:
specs = common.specs_from_url(args.file)
else:
specs = common.specs_from_args(args.packages)
common.check_specs(prefix, specs)
spec_names = set(s.split()[0] for s in specs)
if args.no_deps:
only_names = spec_names
else:
only_names = None
if not isdir(prefix) and not newenv:
if args.mkdir:
try:
os.makedirs(prefix)
except OSError:
sys.exit("Error: could not create directory: %s" % prefix)
else:
sys.exit("""\
Error: environment does not exist: %s
#
# Use 'conda create' to create an environment before installing packages
# into it.
#""" % prefix)
actions = plan.install_actions(prefix, index, specs,
force=args.force, only_names=only_names)
if plan.nothing_to_do(actions):
from conda.cli.main_list import list_packages
regex = '^(%s)$' % '|'.join(spec_names)
print('# All requested packages already installed.')
list_packages(prefix, regex)
return
print()
print("Package plan for installation in environment %s:" % prefix)
plan.display_actions(actions, index)
if command in {'install', 'update'}:
common.check_write(command, prefix)
if not pscheck.main(args):
common.confirm_yn(args)
plan.execute_actions(actions, index, verbose=not args.quiet)
if newenv:
touch_nonadmin(prefix)
print_activate(args.name if args.name else prefix)
def execute_search(args, parser):
import re
from conda.resolve import Resolve
if args.reverse_dependency:
if not args.regex:
parser.error("--reverse-dependency requires at least one package name")
if args.spec:
parser.error("--reverse-dependency does not work with --spec")
pat = None
ms = None
if args.regex:
if args.spec:
ms = ' '.join(args.regex.split('='))
else:
regex = args.regex
if args.full_name:
regex = r'^%s$' % regex
try:
pat = re.compile(regex, re.I)
except re.error as e:
common.error_and_exit(
"'%s' is not a valid regex pattern (exception: %s)" %
(regex, e),
json=args.json,
error_type="ValueError")
prefix = common.get_prefix(args)
import conda.config
import conda.install
linked = conda.install.linked(prefix)
extracted = set()
for pkgs_dir in conda.config.pkgs_dirs:
extracted.update(conda.install.extracted(pkgs_dir))
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != config.subdir:
args.unknown = False
common.ensure_override_channels_requires_channel(args, dashc=False,
json=args.json)
channel_urls = args.channel or ()
if args.use_local:
from conda.fetch import fetch_index
from conda.utils import url_path
try:
from conda_build.config import croot
except ImportError:
common.error_and_exit("you need to have 'conda-build >= 1.7.1' installed"
" to use the --use-local option",
json=args.json,
error_type="RuntimeError")
# remove the cache such that a refetch is made,
# this is necessary because we add the local build repo URL
fetch_index.cache = {}
if exists(croot):
channel_urls = [url_path(croot)] + list(channel_urls)
index = common.get_index_trap(channel_urls=channel_urls,
prepend=not args.override_channels,
use_cache=args.use_index_cache,
unknown=args.unknown, prefix=prefix,
json=args.json, platform=args.platform, offline=args.offline)
else:
index = common.get_index_trap(channel_urls=channel_urls, prepend=not
args.override_channels, platform=args.platform,
use_cache=args.use_index_cache, prefix=prefix,
unknown=args.unknown, json=args.json, offline=args.offline)
r = Resolve(index)
if args.canonical:
json = []
else:
json = {}
names = []
for name in sorted(r.groups):
if '@' in name:
continue
if args.reverse_dependency:
ms_name = ms
for pkg in r.groups[name]:
for dep in r.ms_depends(pkg):
if pat.search(dep.name):
names.append((name, Package(pkg, r.index[pkg])))
else:
if pat and pat.search(name) is None:
continue
if ms and name != ms.name:
continue
if ms:
ms_name = ms
else:
ms_name = name
pkgs = sorted(r.get_pkgs(ms_name))
names.append((name, pkgs))
if args.reverse_dependency:
new_names = []
old = None
for name, pkg in sorted(names, key=lambda x:(x[0], x[1].name, x[1])):
if name == old:
new_names[-1][1].append(pkg)
else:
new_names.append((name, [pkg]))
old = name
names = new_names
for name, pkgs in names:
if args.reverse_dependency:
disp_name = pkgs[0].name
else:
disp_name = name
if args.names_only and not args.outdated:
print(name)
continue
if not args.canonical:
json[name] = []
if args.outdated:
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
if args.names_only:
print(name)
continue
for pkg in pkgs:
dist = pkg.fn[:-8]
if args.canonical:
if not args.json:
print(dist)
else:
json.append(dist)
continue
if platform and platform != config.subdir:
inst = ' '
elif dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
if not args.json:
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name, inst,
pkg.version,
pkg.build,
config.canonical_channel_name(pkg.channel),
common.disp_features(r.features(pkg.fn)),
))
disp_name = ''
else:
data = {}
data.update(pkg.info)
data.update({
'fn': pkg.fn,
'installed': inst == '*',
'extracted': inst in '*.',
'version': pkg.version,
'build': pkg.build,
'build_number': pkg.build_number,
'channel': config.canonical_channel_name(pkg.channel),
'full_channel': pkg.channel,
'features': list(r.features(pkg.fn)),
'license': pkg.info.get('license'),
'size': pkg.info.get('size'),
'depends': pkg.info.get('depends'),
'type': pkg.info.get('type')
})
if data['type'] == 'app':
data['icon'] = make_icon_url(pkg.info)
json[name].append(data)
if args.json:
common.stdout_json(json)
def install(args, parser, command='install'):
"""
conda install, conda update, and conda create
"""
newenv = bool(command == 'create')
if newenv:
common.ensure_name_or_prefix(args, command)
prefix = common.get_prefix(args, search=not newenv)
if newenv:
check_prefix(prefix, json=args.json)
if config.force_32bit and plan.is_root_prefix(prefix):
common.error_and_exit("cannot use CONDA_FORCE_32BIT=1 in root env")
if command == 'update':
if args.all:
if args.packages:
common.error_and_exit("""--all cannot be used with packages""",
json=args.json,
error_type="ValueError")
elif not args.file:
if len(args.packages) == 0:
common.error_and_exit("""no package names supplied
# If you want to update to a newer version of Anaconda, type:
#
# $ conda update --prefix %s anaconda
""" % prefix,
json=args.json,
error_type="ValueError")
if command == 'update':
linked = ci.linked(prefix)
for name in args.packages:
common.arg2spec(name, json=args.json)
if '=' in name:
common.error_and_exit("Invalid package name: '%s'" % (name),
json=args.json,
error_type="ValueError")
if name not in set(ci.name_dist(d) for d in linked):
common.error_and_exit("package '%s' is not installed in %s" %
(name, prefix),
json=args.json,
error_type="ValueError")
if newenv and not args.no_default_packages:
default_packages = config.create_default_packages[:]
# Override defaults if they are specified at the command line
for default_pkg in config.create_default_packages:
if any(pkg.split('=')[0] == default_pkg for pkg in args.packages):
default_packages.remove(default_pkg)
args.packages.extend(default_packages)
else:
default_packages = []
common.ensure_override_channels_requires_channel(args)
channel_urls = args.channel or ()
specs = []
if args.file:
for fpath in args.file:
specs.extend(common.specs_from_url(fpath, json=args.json))
elif getattr(args, 'all', False):
linked = ci.linked(prefix)
if not linked:
common.error_and_exit("There are no packages installed in the "
"prefix %s" % prefix)
for pkg in linked:
name, ver, build = pkg.rsplit('-', 2)
if name in getattr(args, '_skip', ['anaconda']):
continue
if name == 'python' and ver.startswith('2'):
# Oh Python 2...
specs.append('%s >=%s,<3' % (name, ver))
else:
specs.append('%s' % name)
specs.extend(common.specs_from_args(args.packages, json=args.json))
if command == 'install' and args.revision:
get_revision(args.revision, json=args.json)
elif not (newenv and args.clone):
common.check_specs(prefix, specs, json=args.json,
create=(command == 'create'))
num_cp = sum(s.endswith('.tar.bz2') for s in args.packages)
if num_cp:
if num_cp == len(args.packages):
depends = misc.install_local_packages(prefix, args.packages,
verbose=not args.quiet)
if args.no_deps:
depends = []
specs = list(set(depends))
args.unknown = True
else:
common.error_and_exit(
"cannot mix specifications with conda package filenames",
json=args.json,
error_type="ValueError")
# handle tar file containing conda packages
if len(args.packages) == 1:
tar_path = args.packages[0]
if tar_path.endswith('.tar'):
depends = install_tar(prefix, tar_path, verbose=not args.quiet)
if args.no_deps:
depends = []
specs = list(set(depends))
args.unknown = True
if args.use_local:
from conda.fetch import fetch_index
from conda.utils import url_path
try:
from conda_build.config import croot
except ImportError:
common.error_and_exit(
"you need to have 'conda-build >= 1.7.1' installed"
" to use the --use-local option",
json=args.json,
error_type="RuntimeError")
# remove the cache such that a refetch is made,
# this is necessary because we add the local build repo URL
fetch_index.cache = {}
if exists(croot):
channel_urls = [url_path(croot)] + list(channel_urls)
index = common.get_index_trap(channel_urls=channel_urls,
prepend=not args.override_channels,
use_cache=args.use_index_cache,
unknown=args.unknown,
json=args.json,
offline=args.offline)
if newenv and args.clone:
if set(args.packages) - set(default_packages):
common.error_and_exit('did not expect any arguments for --clone',
json=args.json,
error_type="ValueError")
clone(args.clone, prefix, json=args.json, quiet=args.quiet, index=index)
misc.append_env(prefix)
misc.touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
return
# Don't update packages that are already up-to-date
if command == 'update' and not (args.all or args.force):
r = Resolve(index)
orig_packages = args.packages[:]
for name in orig_packages:
installed_metadata = [ci.is_linked(prefix, dist)
for dist in linked]
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
build_inst = [m['build_number'] for m in installed_metadata if
m['name'] == name]
try:
assert len(vers_inst) == 1, name
assert len(build_inst) == 1, name
except AssertionError as e:
if args.json:
common.exception_and_exit(e, json=True)
else:
raise
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
# Shouldn't happen?
continue
latest = pkgs[-1]
if (latest.version == vers_inst[0] and
latest.build_number == build_inst[0]):
args.packages.remove(name)
if not args.packages:
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(orig_packages)
print('# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(
message='All requested packages already installed.')
return
if args.force:
args.no_deps = True
spec_names = set(s.split()[0] for s in specs)
if args.no_deps:
only_names = spec_names
else:
only_names = None
if not isdir(prefix) and not newenv:
if args.mkdir:
try:
os.makedirs(prefix)
except OSError:
common.error_and_exit("Error: could not create directory: %s" % prefix,
json=args.json,
error_type="OSError")
else:
common.error_and_exit("""\
environment does not exist: %s
#
# Use 'conda create' to create an environment before installing packages
# into it.
#""" % prefix,
json=args.json,
error_type="NoEnvironmentFound")
try:
if command == 'install' and args.revision:
actions = plan.revert_actions(prefix, get_revision(args.revision))
else:
with common.json_progress_bars(json=args.json and not args.quiet):
actions = plan.install_actions(prefix, index, specs,
force=args.force,
only_names=only_names,
pinned=args.pinned,
minimal_hint=args.alt_hint)
if args.copy:
new_link = []
for pkg in actions["LINK"]:
dist, pkgs_dir, lt = inst.split_linkarg(pkg)
lt = ci.LINK_COPY
new_link.append("%s %s %d" % (dist, pkgs_dir, lt))
actions["LINK"] = new_link
except NoPackagesFound as e:
error_message = e.args[0]
if command == 'update' and args.all:
# Packages not found here just means they were installed but
# cannot be found any more. Just skip them.
if not args.json:
print("Warning: %s, skipping" % error_message)
else:
# Not sure what to do here
pass
args._skip = getattr(args, '_skip', ['anaconda'])
for pkg in e.pkgs:
p = pkg.split()[0]
if p in args._skip:
# Avoid infinite recursion. This can happen if a spec
# comes from elsewhere, like --file
raise
args._skip.append(p)
return install(args, parser, command=command)
else:
packages = {index[fn]['name'] for fn in index}
for pkg in e.pkgs:
close = get_close_matches(pkg, packages, cutoff=0.7)
if close:
error_message += ("\n\nDid you mean one of these?"
"\n\n %s" % (', '.join(close)))
error_message += '\n\nYou can search for this package on anaconda.org with'
error_message += '\n\n anaconda search -t conda %s' % pkg
if len(e.pkgs) > 1:
# Note this currently only happens with dependencies not found
error_message += '\n\n (and similarly for the other packages)'
if not find_executable('anaconda', include_others=False):
error_message += '\n\nYou may need to install the anaconda-client command line client with'
error_message += '\n\n conda install anaconda-client'
pinned_specs = plan.get_pinned_specs(prefix)
if pinned_specs:
error_message += "\n\nNote that you have pinned specs in %s:" % join(prefix, 'conda-meta', 'pinned')
error_message += "\n\n %r" % pinned_specs
common.error_and_exit(error_message, json=args.json)
except SystemExit as e:
# Unsatisfiable package specifications/no such revision/import error
error_type = 'UnsatisfiableSpecifications'
if e.args and 'could not import' in e.args[0]:
error_type = 'ImportError'
common.exception_and_exit(e, json=args.json, newline=True,
error_text=False,
error_type=error_type)
if plan.nothing_to_do(actions):
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(spec_names)
print('\n# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(
message='All requested packages already installed.')
return
if not args.json:
print()
print("Package plan for installation in environment %s:" % prefix)
plan.display_actions(actions, index)
if command in {'install', 'update'}:
common.check_write(command, prefix)
if not args.json:
common.confirm_yn(args)
elif args.dry_run:
common.stdout_json_success(actions=actions, dry_run=True)
sys.exit(0)
with common.json_progress_bars(json=args.json and not args.quiet):
try:
plan.execute_actions(actions, index, verbose=not args.quiet)
if not (command == 'update' and args.all):
try:
with open(join(prefix, 'conda-meta', 'history'), 'a') as f:
f.write('# %s specs: %s\n' % (command, specs))
except IOError as e:
if e.errno == errno.EACCES:
log.debug("Can't write the history file")
else:
raise
except RuntimeError as e:
if len(e.args) > 0 and "LOCKERROR" in e.args[0]:
error_type = "AlreadyLocked"
else:
error_type = "RuntimeError"
common.exception_and_exit(e, error_type=error_type, json=args.json)
except SystemExit as e:
common.exception_and_exit(e, json=args.json)
if newenv:
misc.append_env(prefix)
misc.touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
if args.json:
common.stdout_json_success(actions=actions)
def execute_search(args, parser):
import re
from conda.resolve import Resolve
if args.reverse_dependency:
if not args.regex:
parser.error("--reverse-dependency requires at least one package name")
if args.spec:
parser.error("--reverse-dependency does not work with --spec")
pat = None
ms = None
if args.regex:
if args.spec:
ms = ' '.join(args.regex.split('='))
else:
regex = args.regex
if args.full_name:
regex = r'^%s$' % regex
try:
pat = re.compile(regex, re.I)
except re.error as e:
raise CondaValueError("'%s' is not a valid regex pattern (exception: %s)" %
(regex, e), args.json)
prefix = get_prefix(args)
import conda.install
linked = conda.install.linked(prefix)
extracted = conda.install.extracted()
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != subdir:
args.unknown = False
ensure_use_local(args)
ensure_override_channels_requires_channel(args, dashc=False)
channel_urls = args.channel or ()
index = get_index_trap(channel_urls=channel_urls, prepend=not args.override_channels,
platform=args.platform, use_local=args.use_local,
use_cache=args.use_index_cache, prefix=prefix,
unknown=args.unknown, json=args.json)
r = Resolve(index)
if args.canonical:
json = []
else:
json = {}
names = []
for name in sorted(r.groups):
if '@' in name:
continue
if args.reverse_dependency:
ms_name = ms
for pkg in r.groups[name]:
for dep in r.ms_depends(pkg):
if pat.search(dep.name):
names.append((name, Package(pkg, r.index[pkg])))
else:
if pat and pat.search(name) is None:
continue
if ms and name != ms.split()[0]:
continue
if ms:
ms_name = ms
else:
ms_name = name
pkgs = sorted(r.get_pkgs(ms_name))
names.append((name, pkgs))
if args.reverse_dependency:
new_names = []
old = None
for name, pkg in sorted(names, key=lambda x: (x[0], x[1].name, x[1])):
if name == old:
new_names[-1][1].append(pkg)
else:
new_names.append((name, [pkg]))
old = name
names = new_names
for name, pkgs in names:
if args.reverse_dependency:
disp_name = pkgs[0].name
else:
disp_name = name
if args.names_only and not args.outdated:
print(name)
continue
if not args.canonical:
json[name] = []
if args.outdated:
vers_inst = [dist[1] for dist in map(dist2quad, linked)
if dist[0] == name]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
if args.names_only:
print(name)
continue
for pkg in pkgs:
dist = pkg.fn[:-8]
if args.canonical:
if not args.json:
print(dist)
else:
json.append(dist)
continue
if platform and platform != subdir:
inst = ' '
elif dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
if not args.json:
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name, inst,
pkg.version,
pkg.build,
canonical_channel_name(pkg.channel),
disp_features(r.features(pkg.fn)),
))
disp_name = ''
else:
data = {}
data.update(pkg.info)
data.update({
'fn': pkg.fn,
'installed': inst == '*',
'extracted': inst in '*.',
'version': pkg.version,
'build': pkg.build,
'build_number': pkg.build_number,
'channel': canonical_channel_name(pkg.channel),
'full_channel': pkg.channel,
'features': list(r.features(pkg.fn)),
'license': pkg.info.get('license'),
'size': pkg.info.get('size'),
'depends': pkg.info.get('depends'),
'type': pkg.info.get('type')
})
if data['type'] == 'app':
data['icon'] = make_icon_url(pkg.info)
json[name].append(data)
if args.json:
stdout_json(json)
def execute_search(args, parser):
import re
from conda.resolve import Resolve
if args.reverse_dependency:
if not args.regex:
parser.error(
"--reverse-dependency requires at least one package name")
if args.spec:
parser.error("--reverse-dependency does not work with --spec")
pat = None
ms = None
if args.regex:
if args.spec:
ms = ' '.join(args.regex.split('='))
else:
regex = args.regex
if args.full_name:
regex = r'^%s$' % regex
try:
pat = re.compile(regex, re.I)
except re.error as e:
error_and_exit(
"'%s' is not a valid regex pattern (exception: %s)" %
(regex, e),
json=args.json,
error_type="ValueError")
prefix = get_prefix(args)
import conda.install
linked = conda.install.linked(prefix)
extracted = conda.install.extracted()
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != subdir:
args.unknown = False
ensure_use_local(args)
ensure_override_channels_requires_channel(args, dashc=False)
channel_urls = args.channel or ()
index = get_index_trap(channel_urls=channel_urls,
prepend=not args.override_channels,
platform=args.platform,
use_local=args.use_local,
use_cache=args.use_index_cache,
prefix=prefix,
unknown=args.unknown,
json=args.json,
offline=args.offline)
r = Resolve(index)
if args.canonical:
json = []
else:
json = {}
names = []
for name in sorted(r.groups):
if '@' in name:
continue
if args.reverse_dependency:
ms_name = ms
for pkg in r.groups[name]:
for dep in r.ms_depends(pkg):
if pat.search(dep.name):
names.append((name, Package(pkg, r.index[pkg])))
else:
if pat and pat.search(name) is None:
continue
if ms and name != ms.split()[0]:
continue
if ms:
ms_name = ms
else:
ms_name = name
pkgs = sorted(r.get_pkgs(ms_name))
names.append((name, pkgs))
if args.reverse_dependency:
new_names = []
old = None
for name, pkg in sorted(names, key=lambda x: (x[0], x[1].name, x[1])):
if name == old:
new_names[-1][1].append(pkg)
else:
new_names.append((name, [pkg]))
old = name
names = new_names
for name, pkgs in names:
if args.reverse_dependency:
disp_name = pkgs[0].name
else:
disp_name = name
if args.names_only and not args.outdated:
print(name)
continue
if not args.canonical:
json[name] = []
if args.outdated:
vers_inst = [
dist[1] for dist in map(dist2quad, linked) if dist[0] == name
]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
if args.names_only:
print(name)
continue
for pkg in pkgs:
dist = pkg.fn[:-8]
if args.canonical:
if not args.json:
print(dist)
else:
json.append(dist)
continue
if platform and platform != subdir:
inst = ' '
elif dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
if not args.json:
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name,
inst,
pkg.version,
pkg.build,
canonical_channel_name(pkg.channel),
disp_features(r.features(pkg.fn)),
))
disp_name = ''
else:
data = {}
data.update(pkg.info)
data.update({
'fn': pkg.fn,
'installed': inst == '*',
'extracted': inst in '*.',
'version': pkg.version,
'build': pkg.build,
'build_number': pkg.build_number,
'channel': canonical_channel_name(pkg.channel),
'full_channel': pkg.channel,
'features': list(r.features(pkg.fn)),
'license': pkg.info.get('license'),
'size': pkg.info.get('size'),
'depends': pkg.info.get('depends'),
'type': pkg.info.get('type')
})
if data['type'] == 'app':
data['icon'] = make_icon_url(pkg.info)
json[name].append(data)
if args.json:
stdout_json(json)
def execute(args, parser):
import os
from os.path import basename, dirname
import conda
import conda.config as config
import conda.misc as misc
from conda.resolve import Resolve, MatchSpec
from conda.cli.main_init import is_initialized
from conda.api import get_index, get_package_versions
if args.packages:
if args.json:
results = defaultdict(list)
for arg in args.packages:
for pkg in get_package_versions(arg):
results[arg].append(pkg._asdict())
common.stdout_json(results)
return
index = get_index()
r = Resolve(index)
specs = map(common.arg2spec, args.packages)
for spec in specs:
versions = r.get_pkgs(MatchSpec(spec))
for pkg in versions:
pretty_package(pkg)
return
options = 'envs', 'system', 'license'
try:
import requests
requests_version = requests.__version__
except ImportError:
requests_version = "could not import"
except Exception as e:
requests_version = "Error %s" % e
try:
import conda_build
except ImportError:
conda_build_version = "not installed"
except Exception as e:
conda_build_version = "Error %s" % e
else:
conda_build_version = conda_build.__version__
info_dict = dict(
platform=config.subdir,
conda_version=conda.__version__,
conda_build_version=conda_build_version,
root_prefix=config.root_dir,
root_writable=config.root_writable,
pkgs_dirs=config.pkgs_dirs,
envs_dirs=config.envs_dirs,
default_prefix=config.default_prefix,
channels=config.get_channel_urls(),
rc_path=config.rc_path,
is_foreign=bool(config.foreign),
envs=[],
python_version='.'.join(map(str, sys.version_info)),
requests_version=requests_version,
)
if args.all or args.json:
for option in options:
setattr(args, option, True)
info_dict['channels_disp'] = [
config.hide_binstar_tokens(c) for c in info_dict['channels']
]
if args.all or all(not getattr(args, opt) for opt in options):
for key in 'pkgs_dirs', 'envs_dirs', 'channels_disp':
info_dict['_' + key] = ('\n' + 24 * ' ').join(info_dict[key])
info_dict['_rtwro'] = ('writable'
if info_dict['root_writable'] else 'read only')
print("""\
Current conda install:
platform : %(platform)s
conda version : %(conda_version)s
conda-build version : %(conda_build_version)s
python version : %(python_version)s
requests version : %(requests_version)s
root environment : %(root_prefix)s (%(_rtwro)s)
default environment : %(default_prefix)s
envs directories : %(_envs_dirs)s
package cache : %(_pkgs_dirs)s
channel URLs : %(_channels_disp)s
config file : %(rc_path)s
is foreign system : %(is_foreign)s
""" % info_dict)
if not is_initialized():
print("""\
# NOTE:
# root directory '%s' is uninitialized""" % config.root_dir)
del info_dict['channels_disp']
if args.envs:
if not args.json:
print("# conda environments:")
print("#")
def disp_env(prefix):
fmt = '%-20s %s %s'
default = '*' if prefix == config.default_prefix else ' '
name = (config.root_env_name
if prefix == config.root_dir else basename(prefix))
if not args.json:
print(fmt % (name, default, prefix))
for prefix in misc.list_prefixes():
disp_env(prefix)
if prefix != config.root_dir:
info_dict['envs'].append(prefix)
print()
if args.system and not args.json:
from conda.cli.find_commands import find_commands, find_executable
print("sys.version: %s..." % (sys.version[:40]))
print("sys.prefix: %s" % sys.prefix)
print("sys.executable: %s" % sys.executable)
print("conda location: %s" % dirname(conda.__file__))
for cmd in sorted(set(find_commands() + ['build'])):
print("conda-%s: %s" % (cmd, find_executable('conda-' + cmd)))
print("user site dirs: ", end='')
site_dirs = get_user_site()
if site_dirs:
print(site_dirs[0])
else:
print()
for site_dir in site_dirs[1:]:
print(' %s' % site_dir)
print()
evars = [
'PATH', 'PYTHONPATH', 'PYTHONHOME', 'CONDA_DEFAULT_ENV',
'CIO_TEST', 'CONDA_ENVS_PATH'
]
if config.platform == 'linux':
evars.append('LD_LIBRARY_PATH')
elif config.platform == 'osx':
evars.append('DYLD_LIBRARY_PATH')
for ev in sorted(evars):
print("%s: %s" % (ev, os.getenv(ev, '<not set>')))
print()
if args.license and not args.json:
try:
from _license import show_info
show_info()
except ImportError:
print("""\
WARNING: could not import _license.show_info
# try:
# $ conda install -n root _license""")
if args.json:
common.stdout_json(info_dict)
def install(args, parser, command='install'):
"""
conda install, conda update, and conda create
"""
newenv = bool(command == 'create')
isupdate = bool(command == 'update')
isinstall = bool(command == 'install')
if newenv:
common.ensure_name_or_prefix(args, command)
prefix = common.get_prefix(args, search=not newenv)
if newenv:
check_prefix(prefix, json=args.json)
if force_32bit and plan.is_root_prefix(prefix):
common.error_and_exit("cannot use CONDA_FORCE_32BIT=1 in root env")
if isupdate and not (args.file or args.all or args.packages):
common.error_and_exit("""no package names supplied
# If you want to update to a newer version of Anaconda, type:
#
# $ conda update --prefix %s anaconda
""" % prefix,
json=args.json,
error_type="ValueError")
linked = ci.linked(prefix)
lnames = {ci.name_dist(d) for d in linked}
if isupdate and not args.all:
for name in args.packages:
common.arg2spec(name, json=args.json, update=True)
if name not in lnames:
common.error_and_exit("Package '%s' is not installed in %s" %
(name, prefix),
json=args.json,
error_type="ValueError")
if newenv and not args.no_default_packages:
default_packages = create_default_packages[:]
# Override defaults if they are specified at the command line
for default_pkg in create_default_packages:
if any(pkg.split('=')[0] == default_pkg for pkg in args.packages):
default_packages.remove(default_pkg)
args.packages.extend(default_packages)
else:
default_packages = []
common.ensure_use_local(args)
common.ensure_override_channels_requires_channel(args)
channel_urls = args.channel or ()
specs = []
if args.file:
for fpath in args.file:
specs.extend(common.specs_from_url(fpath, json=args.json))
if '@EXPLICIT' in specs:
misc.explicit(specs, prefix, verbose=not args.quiet)
return
elif getattr(args, 'all', False):
if not linked:
common.error_and_exit("There are no packages installed in the "
"prefix %s" % prefix)
specs.extend(nm for nm in lnames)
specs.extend(common.specs_from_args(args.packages, json=args.json))
if isinstall and args.revision:
get_revision(args.revision, json=args.json)
elif not (newenv and args.clone):
common.check_specs(prefix, specs, json=args.json,
create=(command == 'create'))
num_cp = sum(s.endswith('.tar.bz2') for s in args.packages)
if num_cp:
if num_cp == len(args.packages):
misc.explicit(args.packages, prefix, verbose=not args.quiet)
return
else:
common.error_and_exit(
"cannot mix specifications with conda package filenames",
json=args.json,
error_type="ValueError")
# handle tar file containing conda packages
if len(args.packages) == 1:
tar_path = args.packages[0]
if tar_path.endswith('.tar'):
install_tar(prefix, tar_path, verbose=not args.quiet)
return
if newenv and args.clone:
if set(args.packages) - set(default_packages):
common.error_and_exit('did not expect any arguments for --clone',
json=args.json,
error_type="ValueError")
clone(args.clone, prefix, json=args.json, quiet=args.quiet,
fetch_args={'use_cache': args.use_index_cache,
'unknown': args.unknown})
misc.append_env(prefix)
misc.touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
return
index = common.get_index_trap(channel_urls=channel_urls,
prepend=not args.override_channels,
use_local=args.use_local,
use_cache=args.use_index_cache,
unknown=args.unknown,
json=args.json,
offline=args.offline,
prefix=prefix)
r = Resolve(index)
ospecs = list(specs)
plan.add_defaults_to_specs(r, linked, specs, update=isupdate)
# Don't update packages that are already up-to-date
if isupdate and not (args.all or args.force):
orig_packages = args.packages[:]
installed_metadata = [ci.is_linked(prefix, dist) for dist in linked]
for name in orig_packages:
vers_inst = [m['version'] for m in installed_metadata if m['name'] == name]
build_inst = [m['build_number'] for m in installed_metadata if m['name'] == name]
try:
assert len(vers_inst) == 1, name
assert len(build_inst) == 1, name
except AssertionError as e:
if args.json:
common.exception_and_exit(e, json=True)
else:
raise
pkgs = sorted(r.get_pkgs(name))
if not pkgs:
# Shouldn't happen?
continue
latest = pkgs[-1]
if (latest.version == vers_inst[0] and
latest.build_number == build_inst[0]):
args.packages.remove(name)
if not args.packages:
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(orig_packages)
print('# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(
message='All requested packages already installed.')
return
if args.force:
args.no_deps = True
if args.no_deps:
only_names = set(s.split()[0] for s in ospecs)
else:
only_names = None
if not isdir(prefix) and not newenv:
if args.mkdir:
try:
os.makedirs(prefix)
except OSError:
common.error_and_exit("Error: could not create directory: %s" % prefix,
json=args.json,
error_type="OSError")
else:
common.error_and_exit("""\
environment does not exist: %s
#
# Use 'conda create' to create an environment before installing packages
# into it.
#""" % prefix,
json=args.json,
error_type="NoEnvironmentFound")
try:
if isinstall and args.revision:
actions = plan.revert_actions(prefix, get_revision(args.revision))
else:
with common.json_progress_bars(json=args.json and not args.quiet):
actions = plan.install_actions(prefix, index, specs,
force=args.force,
only_names=only_names,
pinned=args.pinned,
always_copy=args.copy,
minimal_hint=args.alt_hint,
update_deps=args.update_deps)
except NoPackagesFound as e:
error_message = e.args[0]
if isupdate and args.all:
# Packages not found here just means they were installed but
# cannot be found any more. Just skip them.
if not args.json:
print("Warning: %s, skipping" % error_message)
else:
# Not sure what to do here
pass
args._skip = getattr(args, '_skip', ['anaconda'])
for pkg in e.pkgs:
p = pkg.split()[0]
if p in args._skip:
# Avoid infinite recursion. This can happen if a spec
# comes from elsewhere, like --file
raise
args._skip.append(p)
return install(args, parser, command=command)
else:
packages = {index[fn]['name'] for fn in index}
nfound = 0
for pkg in sorted(e.pkgs):
pkg = pkg.split()[0]
if pkg in packages:
continue
close = get_close_matches(pkg, packages, cutoff=0.7)
if not close:
continue
if nfound == 0:
error_message += "\n\nClose matches found; did you mean one of these?\n"
error_message += "\n %s: %s" % (pkg, ', '.join(close))
nfound += 1
error_message += '\n\nYou can search for packages on anaconda.org with'
error_message += '\n\n anaconda search -t conda %s' % pkg
if len(e.pkgs) > 1:
# Note this currently only happens with dependencies not found
error_message += '\n\n(and similarly for the other packages)'
if not find_executable('anaconda', include_others=False):
error_message += '\n\nYou may need to install the anaconda-client'
error_message += ' command line client with'
error_message += '\n\n conda install anaconda-client'
pinned_specs = plan.get_pinned_specs(prefix)
if pinned_specs:
path = join(prefix, 'conda-meta', 'pinned')
error_message += "\n\nNote that you have pinned specs in %s:" % path
error_message += "\n\n %r" % pinned_specs
common.error_and_exit(error_message, json=args.json)
except (Unsatisfiable, SystemExit) as e:
# Unsatisfiable package specifications/no such revision/import error
error_type = 'UnsatisfiableSpecifications'
if e.args and 'could not import' in e.args[0]:
error_type = 'ImportError'
common.exception_and_exit(e, json=args.json, newline=True,
error_text=False,
error_type=error_type)
if plan.nothing_to_do(actions):
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(s.split()[0] for s in ospecs)
print('\n# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(
message='All requested packages already installed.')
return
if not args.json:
print()
print("Package plan for installation in environment %s:" % prefix)
plan.display_actions(actions, index, show_channel_urls=args.show_channel_urls)
if command in {'install', 'update'}:
common.check_write(command, prefix)
if not args.json:
common.confirm_yn(args)
elif args.dry_run:
common.stdout_json_success(actions=actions, dry_run=True)
sys.exit(0)
with common.json_progress_bars(json=args.json and not args.quiet):
try:
plan.execute_actions(actions, index, verbose=not args.quiet)
if not (command == 'update' and args.all):
try:
with open(join(prefix, 'conda-meta', 'history'), 'a') as f:
f.write('# %s specs: %s\n' % (command, specs))
except IOError as e:
if e.errno == errno.EACCES:
log.debug("Can't write the history file")
else:
raise
except RuntimeError as e:
if len(e.args) > 0 and "LOCKERROR" in e.args[0]:
error_type = "AlreadyLocked"
else:
error_type = "RuntimeError"
common.exception_and_exit(e, error_type=error_type, json=args.json)
except SystemExit as e:
common.exception_and_exit(e, json=args.json)
if newenv:
misc.append_env(prefix)
misc.touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
if args.json:
common.stdout_json_success(actions=actions)
def execute_search(args, parser):
import re
import sys
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
pat = None
ms = None
if args.regex:
if args.spec:
ms = MatchSpec(' '.join(args.regex.split('=')))
else:
try:
pat = re.compile(args.regex, re.I)
except re.error as e:
common.error_and_exit("%r is not a valid regex pattern (exception: %s)" %
(args.regex, e),
json=args.json,
error_type="ValueError")
prefix = common.get_prefix(args)
import conda.config
import conda.install
linked = conda.install.linked(prefix)
extracted = set()
for pkgs_dir in conda.config.pkgs_dirs:
extracted.update(conda.install.extracted(pkgs_dir))
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != config.subdir:
args.unknown = False
common.ensure_override_channels_requires_channel(args, dashc=False,
json=args.json)
channel_urls = args.channel or ()
index = common.get_index_trap(channel_urls=channel_urls, prepend=not
args.override_channels, platform=args.platform,
use_cache=args.use_index_cache,
unknown=args.unknown, json=args.json)
r = Resolve(index)
if args.canonical:
json = []
else:
json = {}
for name in sorted(r.groups):
disp_name = name
if pat and pat.search(name) is None:
continue
if ms and name != ms.name:
continue
if ms:
ms_name = ms
else:
ms_name = MatchSpec(name)
if not args.canonical:
json[name] = []
if args.outdated:
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
pkgs = sorted(r.get_pkgs(ms_name))
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
for pkg in sorted(r.get_pkgs(ms_name)):
dist = pkg.fn[:-8]
if args.canonical:
if not args.json:
print(dist)
else:
json.append(dist)
continue
if dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
if not args.json:
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name, inst,
pkg.version,
pkg.build,
config.canonical_channel_name(pkg.channel),
common.disp_features(r.features(pkg.fn)),
))
disp_name = ''
else:
data = {}
data.update(pkg.info)
data.update({
'fn': pkg.fn,
'installed': inst == '*',
'extracted': inst in '*.',
'version': pkg.version,
'build': pkg.build,
'build_number': pkg.build_number,
'channel': config.canonical_channel_name(pkg.channel),
'full_channel': pkg.channel,
'features': list(r.features(pkg.fn)),
'license': pkg.info.get('license'),
'size': pkg.info.get('size'),
'depends': pkg.info.get('depends'),
'type': pkg.info.get('type')
})
if data['type'] == 'app':
data['icon'] = make_icon_url(pkg.info)
json[name].append(data)
if args.json:
common.stdout_json(json)
def get_package_versions(package, offline=False):
index = get_index(offline=offline)
r = Resolve(index)
return r.get_pkgs(package, emptyok=True)
def execute(args, parser):
import os
from os.path import dirname
import conda
from conda.config import (root_dir, get_channel_urls, subdir, pkgs_dirs,
root_writable, envs_dirs, default_prefix, rc_path,
user_rc_path, sys_rc_path, foreign, hide_binstar_tokens,
platform, offline)
from conda.resolve import Resolve
from conda.api import get_index
if args.root:
if args.json:
stdout_json({'root_prefix': root_dir})
else:
print(root_dir)
return
if args.packages:
index = get_index()
r = Resolve(index)
if args.json:
stdout_json({
package: [p._asdict()
for p in sorted(r.get_pkgs(arg2spec(package)))]
for package in args.packages
})
else:
for package in args.packages:
versions = r.get_pkgs(arg2spec(package))
for pkg in sorted(versions):
pretty_package(pkg)
return
options = 'envs', 'system', 'license'
try:
from conda.install import linked_data
root_pkgs = linked_data(sys.prefix)
except:
root_pkgs = None
try:
from .._vendor.requests import __version__ as requests_version
except ImportError:
requests_version = "could not import"
except Exception as e:
requests_version = "Error %s" % e
try:
cenv = [p for p in itervalues(root_pkgs) if p['name'] == 'conda-env']
conda_env_version = cenv[0]['version']
except:
conda_env_version = "not installed"
try:
import conda_build
except ImportError:
conda_build_version = "not installed"
except Exception as e:
conda_build_version = "Error %s" % e
else:
conda_build_version = conda_build.__version__
channels = get_channel_urls(offline=offline)
info_dict = dict(
platform=subdir,
conda_version=conda.__version__,
conda_env_version=conda_env_version,
conda_build_version=conda_build_version,
root_prefix=root_dir,
root_writable=root_writable,
pkgs_dirs=pkgs_dirs,
envs_dirs=envs_dirs,
default_prefix=default_prefix,
channels=channels,
rc_path=rc_path,
user_rc_path=user_rc_path,
sys_rc_path=sys_rc_path,
is_foreign=bool(foreign),
offline=offline,
envs=[],
python_version='.'.join(map(str, sys.version_info)),
requests_version=requests_version,
)
if args.unsafe_channels:
if not args.json:
print("\n".join(info_dict["channels"]))
else:
print(json.dumps({"channels": info_dict["channels"]}))
return 0
else:
info_dict['channels'] = [hide_binstar_tokens(c) for c in
info_dict['channels']]
if args.all or args.json:
for option in options:
setattr(args, option, True)
if args.all or all(not getattr(args, opt) for opt in options):
for key in 'pkgs_dirs', 'envs_dirs', 'channels':
info_dict['_' + key] = ('\n' + 24 * ' ').join(info_dict[key])
info_dict['_rtwro'] = ('writable' if info_dict['root_writable'] else
'read only')
print("""\
Current conda install:
platform : %(platform)s
conda version : %(conda_version)s
conda-env version : %(conda_env_version)s
conda-build version : %(conda_build_version)s
python version : %(python_version)s
requests version : %(requests_version)s
root environment : %(root_prefix)s (%(_rtwro)s)
default environment : %(default_prefix)s
envs directories : %(_envs_dirs)s
package cache : %(_pkgs_dirs)s
channel URLs : %(_channels)s
config file : %(rc_path)s
offline mode : %(offline)s
is foreign system : %(is_foreign)s
""" % info_dict)
if args.envs:
handle_envs_list(info_dict['envs'], not args.json)
if args.system and not args.json:
from conda.cli.find_commands import find_commands, find_executable
print("sys.version: %s..." % (sys.version[:40]))
print("sys.prefix: %s" % sys.prefix)
print("sys.executable: %s" % sys.executable)
print("conda location: %s" % dirname(conda.__file__))
for cmd in sorted(set(find_commands() + ['build'])):
print("conda-%s: %s" % (cmd, find_executable('conda-' + cmd)))
print("user site dirs: ", end='')
site_dirs = get_user_site()
if site_dirs:
print(site_dirs[0])
else:
print()
for site_dir in site_dirs[1:]:
print(' %s' % site_dir)
print()
evars = ['PATH', 'PYTHONPATH', 'PYTHONHOME', 'CONDA_DEFAULT_ENV',
'CIO_TEST', 'CONDA_ENVS_PATH']
if platform == 'linux':
evars.append('LD_LIBRARY_PATH')
elif platform == 'osx':
evars.append('DYLD_LIBRARY_PATH')
for ev in sorted(evars):
print("%s: %s" % (ev, os.getenv(ev, '<not set>')))
print()
if args.license and not args.json:
try:
from _license import show_info
show_info()
except ImportError:
print("""\
WARNING: could not import _license.show_info
# try:
# $ conda install -n root _license""")
if args.json:
stdout_json(info_dict)
def install(args, parser, command='install'):
"""
conda install, conda update, and conda create
"""
newenv = bool(command == 'create')
if newenv:
common.ensure_name_or_prefix(args, command)
prefix = common.get_prefix(args, search=not newenv)
if newenv:
check_prefix(prefix, json=args.json)
if command == 'update':
if args.all:
if args.packages:
common.error_and_exit("""--all cannot be used with packages""",
json=args.json,
error_type="ValueError")
else:
if len(args.packages) == 0:
common.error_and_exit("""no package names supplied
# If you want to update to a newer version of Anaconda, type:
#
# $ conda update --prefix %s anaconda
""" % prefix,
json=args.json,
error_type="ValueError")
if command == 'update':
linked = ci.linked(prefix)
for name in args.packages:
common.arg2spec(name, json=args.json)
if '=' in name:
common.error_and_exit("Invalid package name: '%s'" % (name),
json=args.json,
error_type="ValueError")
if name not in set(ci.name_dist(d) for d in linked):
common.error_and_exit("package '%s' is not installed in %s" %
(name, prefix),
json=args.json,
error_type="ValueError")
if newenv and args.clone:
if args.packages:
common.error_and_exit('did not expect any arguments for --clone',
json=args.json,
error_type="ValueError")
clone(args.clone, prefix, json=args.json, quiet=args.quiet)
touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
return
if newenv and not args.no_default_packages:
default_packages = config.create_default_packages[:]
# Override defaults if they are specified at the command line
for default_pkg in config.create_default_packages:
if any(pkg.split('=')[0] == default_pkg for pkg in args.packages):
default_packages.remove(default_pkg)
args.packages.extend(default_packages)
common.ensure_override_channels_requires_channel(args)
channel_urls = args.channel or ()
specs = []
if args.file:
specs.extend(common.specs_from_url(args.file, json=args.json))
elif getattr(args, 'all', False):
linked = ci.linked(prefix)
for pkg in linked:
name, ver, build = pkg.rsplit('-', 2)
if name == 'python' and ver.startswith('2'):
# Oh Python 2...
specs.append('%s >=%s,<3' % (name, ver))
else:
specs.append('%s >=%s' % (name, ver))
specs.extend(common.specs_from_args(args.packages, json=args.json))
if command == 'install' and args.revision:
get_revision(args.revision, json=args.json)
else:
common.check_specs(prefix, specs, json=args.json)
if args.use_local:
from conda.fetch import fetch_index
from conda.utils import url_path
try:
from conda_build import config as build_config
except ImportError:
common.error_and_exit("you need to have 'conda-build' installed"
" to use the --use-local option",
json=args.json,
error_type="RuntimeError")
# remove the cache such that a refetch is made,
# this is necessary because we add the local build repo URL
fetch_index.cache = {}
index = common.get_index_trap([url_path(build_config.croot)],
use_cache=args.use_index_cache,
unknown=args.unknown,
json=args.json)
else:
index = common.get_index_trap(channel_urls=channel_urls, prepend=not
args.override_channels,
use_cache=args.use_index_cache,
unknown=args.unknown,
json=args.json)
# Don't update packages that are already up-to-date
if command == 'update' and not args.all:
r = Resolve(index)
orig_packages = args.packages[:]
for name in orig_packages:
installed_metadata = [ci.is_linked(prefix, dist)
for dist in linked]
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
build_inst = [m['build_number'] for m in installed_metadata if
m['name'] == name]
try:
assert len(vers_inst) == 1, name
assert len(build_inst) == 1, name
except AssertionError as e:
if args.json:
common.exception_and_exit(e, json=True)
else:
raise
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
# Shouldn't happen?
continue
latest = pkgs[-1]
if latest.version == vers_inst[0] and latest.build_number == build_inst[0]:
args.packages.remove(name)
if not args.packages:
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(orig_packages)
print('# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(message='All requested packages already installed.')
return
# handle tar file containing conda packages
if len(args.packages) == 1:
tar_path = args.packages[0]
if tar_path.endswith('.tar'):
install_tar(prefix, tar_path, verbose=not args.quiet)
return
# handle explicit installs of conda packages
if args.packages and all(s.endswith('.tar.bz2') for s in args.packages):
from conda.misc import install_local_packages
install_local_packages(prefix, args.packages, verbose=not args.quiet)
return
if any(s.endswith('.tar.bz2') for s in args.packages):
common.error_and_exit("cannot mix specifications with conda package filenames",
json=args.json,
error_type="ValueError")
if args.force:
args.no_deps = True
spec_names = set(s.split()[0] for s in specs)
if args.no_deps:
only_names = spec_names
else:
only_names = None
if not isdir(prefix) and not newenv:
if args.mkdir:
try:
os.makedirs(prefix)
except OSError:
common.error_and_exit("Error: could not create directory: %s" % prefix,
json=args.json,
error_type="OSError")
else:
common.error_and_exit("""\
environment does not exist: %s
#
# Use 'conda create' to create an environment before installing packages
# into it.
#""" % prefix,
json=args.json,
error_type="NoEnvironmentFound")
try:
if command == 'install' and args.revision:
actions = plan.revert_actions(prefix, get_revision(args.revision))
else:
actions = plan.install_actions(prefix, index, specs, force=args.force,
only_names=only_names, pinned=args.pinned, minimal_hint=args.alt_hint)
except NoPackagesFound as e:
common.exception_and_exit(e, json=args.json)
except SystemExit as e:
# Unsatisfiable package specifications/no such revision/import error
error_type = 'UnsatisfiableSpecifications'
if e.args and 'could not import' in e.args[0]:
error_type = 'ImportError'
common.exception_and_exit(e, json=args.json, newline=True,
error_text=False,
error_type=error_type)
if plan.nothing_to_do(actions):
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(spec_names)
print('\n# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(message='All requested packages already installed.')
return
if not args.json:
print()
print("Package plan for installation in environment %s:" % prefix)
plan.display_actions(actions, index)
if command in {'install', 'update'}:
common.check_write(command, prefix)
if not args.json:
if not pscheck.main(args):
common.confirm_yn(args)
else:
if (sys.platform == 'win32' and not args.force_pscheck and
not pscheck.check_processes(verbose=False)):
common.error_and_exit("Cannot continue operation while processes "
"from packages are running without --force-pscheck.",
json=True,
error_type="ProcessesStillRunning")
elif args.dry_run:
common.stdout_json_success(actions=actions, dry_run=True)
sys.exit(0)
with common.json_progress_bars(json=args.json and not args.quiet):
try:
plan.execute_actions(actions, index, verbose=not args.quiet)
except RuntimeError as e:
if len(e.args) > 0 and "LOCKERROR" in e.args[0]:
error_type = "AlreadyLocked"
else:
error_type = "RuntimeError"
common.exception_and_exit(e, error_type=error_type, json=args.json)
except SystemExit as e:
common.exception_and_exit(e, json=args.json)
if newenv:
touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
if args.json:
common.stdout_json_success(actions=actions)
def execute_search(args, parser):
import re
from conda.resolve import Resolve
if args.reverse_dependency:
if not args.regex:
parser.error("--reverse-dependency requires at least one package name")
if args.spec:
parser.error("--reverse-dependency does not work with --spec")
pat = None
ms = None
if args.regex:
if args.spec:
ms = ' '.join(args.regex.split('='))
else:
regex = args.regex
if args.full_name:
regex = r'^%s$' % regex
try:
pat = re.compile(regex, re.I)
except re.error as e:
raise CommandArgumentError("Failed to compile regex pattern for "
"search: %(regex)s\n"
"regex error: %(regex_error)s",
regex=regex, regex_error=repr(e))
prefix = context.prefix_w_legacy_search
from ..core.linked_data import linked as linked_data
from ..core.package_cache import PackageCache
linked = linked_data(prefix)
extracted = set(pc_entry.dist.name for pc_entry in PackageCache.get_all_extracted_entries())
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != context.subdir:
args.unknown = False
ensure_use_local(args)
ensure_override_channels_requires_channel(args, dashc=False)
channel_urls = args.channel or ()
index = get_index(channel_urls=channel_urls, prepend=not args.override_channels,
platform=args.platform, use_local=args.use_local,
use_cache=args.use_index_cache, prefix=None,
unknown=args.unknown)
r = Resolve(index)
if args.canonical:
json = []
else:
json = {}
names = []
for name in sorted(r.groups):
if '@' in name:
continue
if args.reverse_dependency:
ms_name = ms
for pkg in r.groups[name]:
for dep in r.ms_depends(pkg):
if pat.search(dep.name):
names.append((name, Package(pkg, r.index[pkg])))
else:
if pat and pat.search(name) is None:
continue
if ms and name != ms.split()[0]:
continue
if ms:
ms_name = ms
else:
ms_name = name
pkgs = sorted(r.get_pkgs(ms_name))
names.append((name, pkgs))
if args.reverse_dependency:
new_names = []
old = None
for name, pkg in sorted(names, key=lambda x: (x[0], x[1].name, x[1])):
if name == old:
new_names[-1][1].append(pkg)
else:
new_names.append((name, [pkg]))
old = name
names = new_names
for name, pkgs in names:
if args.reverse_dependency:
disp_name = pkgs[0].name
else:
disp_name = name
if args.names_only and not args.outdated:
print(name)
continue
if not args.canonical:
json[name] = []
if args.outdated:
vers_inst = [dist.quad[1] for dist in linked if dist.quad[0] == name]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
if args.names_only:
print(name)
continue
for pkg in pkgs:
dist = Dist(pkg)
if args.canonical:
if not context.json:
print(dist.dist_name)
else:
json.append(dist.dist_name)
continue
if platform and platform != context.subdir:
inst = ' '
elif dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
features = r.features(dist)
if not context.json:
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name, inst,
pkg.version,
pkg.build,
pkg.schannel,
disp_features(features),
))
disp_name = ''
else:
data = {}
data.update(pkg.info.dump())
data.update({
'fn': pkg.fn,
'installed': inst == '*',
'extracted': inst in '*.',
'version': pkg.version,
'build': pkg.build,
'build_number': pkg.build_number,
'channel': pkg.schannel,
'full_channel': pkg.channel,
'features': list(features),
'license': pkg.info.get('license'),
'size': pkg.info.get('size'),
'depends': pkg.info.get('depends'),
'type': pkg.info.get('type')
})
if data['type'] == 'app':
data['icon'] = make_icon_url(pkg.info)
json[name].append(data)
if context.json:
stdout_json(json)
def execute(args, parser):
import os
from os.path import dirname
import conda
from conda.config import (root_dir, get_channel_urls, subdir, pkgs_dirs,
root_writable, envs_dirs, default_prefix,
rc_path, user_rc_path, sys_rc_path, foreign,
hide_binstar_tokens, platform, offline)
from conda.resolve import Resolve
from conda.api import get_index
if args.root:
if args.json:
stdout_json({'root_prefix': root_dir})
else:
print(root_dir)
return
if args.packages:
index = get_index()
r = Resolve(index)
if args.json:
stdout_json({
package:
[p._asdict() for p in sorted(r.get_pkgs(arg2spec(package)))]
for package in args.packages
})
else:
for package in args.packages:
versions = r.get_pkgs(arg2spec(package))
for pkg in sorted(versions):
pretty_package(pkg)
return
options = 'envs', 'system', 'license'
try:
from conda.install import linked_data
root_pkgs = linked_data(sys.prefix)
except:
root_pkgs = None
try:
import requests
requests_version = requests.__version__
except ImportError:
requests_version = "could not import"
except Exception as e:
requests_version = "Error %s" % e
try:
cenv = [p for p in itervalues(root_pkgs) if p['name'] == 'conda-env']
conda_env_version = cenv[0]['version']
except:
conda_env_version = "not installed"
try:
import conda_build
except ImportError:
conda_build_version = "not installed"
except Exception as e:
conda_build_version = "Error %s" % e
else:
conda_build_version = conda_build.__version__
channels = get_channel_urls(offline=offline)
info_dict = dict(
platform=subdir,
conda_version=conda.__version__,
conda_env_version=conda_env_version,
conda_build_version=conda_build_version,
root_prefix=root_dir,
root_writable=root_writable,
pkgs_dirs=pkgs_dirs,
envs_dirs=envs_dirs,
default_prefix=default_prefix,
channels=channels,
rc_path=rc_path,
user_rc_path=user_rc_path,
sys_rc_path=sys_rc_path,
is_foreign=bool(foreign),
offline=offline,
envs=[],
python_version='.'.join(map(str, sys.version_info)),
requests_version=requests_version,
)
if args.unsafe_channels:
if not args.json:
print("\n".join(info_dict["channels"]))
else:
print(json.dumps({"channels": info_dict["channels"]}))
return 0
else:
info_dict['channels'] = [
hide_binstar_tokens(c) for c in info_dict['channels']
]
if args.all or args.json:
for option in options:
setattr(args, option, True)
if args.all or all(not getattr(args, opt) for opt in options):
for key in 'pkgs_dirs', 'envs_dirs', 'channels':
info_dict['_' + key] = ('\n' + 24 * ' ').join(info_dict[key])
info_dict['_rtwro'] = ('writable'
if info_dict['root_writable'] else 'read only')
print("""\
Current conda install:
platform : %(platform)s
conda version : %(conda_version)s
conda-env version : %(conda_env_version)s
conda-build version : %(conda_build_version)s
python version : %(python_version)s
requests version : %(requests_version)s
root environment : %(root_prefix)s (%(_rtwro)s)
default environment : %(default_prefix)s
envs directories : %(_envs_dirs)s
package cache : %(_pkgs_dirs)s
channel URLs : %(_channels)s
config file : %(rc_path)s
offline mode : %(offline)s
is foreign system : %(is_foreign)s
""" % info_dict)
if args.envs:
handle_envs_list(info_dict['envs'], not args.json)
if args.system and not args.json:
from conda.cli.find_commands import find_commands, find_executable
print("sys.version: %s..." % (sys.version[:40]))
print("sys.prefix: %s" % sys.prefix)
print("sys.executable: %s" % sys.executable)
print("conda location: %s" % dirname(conda.__file__))
for cmd in sorted(set(find_commands() + ['build'])):
print("conda-%s: %s" % (cmd, find_executable('conda-' + cmd)))
print("user site dirs: ", end='')
site_dirs = get_user_site()
if site_dirs:
print(site_dirs[0])
else:
print()
for site_dir in site_dirs[1:]:
print(' %s' % site_dir)
print()
evars = [
'PATH', 'PYTHONPATH', 'PYTHONHOME', 'CONDA_DEFAULT_ENV',
'CIO_TEST', 'CONDA_ENVS_PATH'
]
if platform == 'linux':
evars.append('LD_LIBRARY_PATH')
elif platform == 'osx':
evars.append('DYLD_LIBRARY_PATH')
for ev in sorted(evars):
print("%s: %s" % (ev, os.getenv(ev, '<not set>')))
print()
if args.license and not args.json:
try:
from _license import show_info
show_info()
except ImportError:
print("""\
WARNING: could not import _license.show_info
# try:
# $ conda install -n root _license""")
if args.json:
stdout_json(info_dict)
def execute(args, parser):
import os
from os.path import dirname
import conda
import conda.config as config
from conda.resolve import Resolve
from conda.cli.main_init import is_initialized
from conda.api import get_index
if args.root:
if args.json:
common.stdout_json({'root_prefix': config.root_dir})
else:
print(config.root_dir)
return
if args.packages:
index = get_index()
r = Resolve(index)
if args.json:
common.stdout_json({
package: [p._asdict()
for p in sorted(r.get_pkgs(common.arg2spec(package)))]
for package in args.packages
})
else:
for package in args.packages:
versions = r.get_pkgs(common.arg2spec(package))
for pkg in sorted(versions):
pretty_package(pkg)
return
options = 'envs', 'system', 'license'
try:
import requests
requests_version = requests.__version__
except ImportError:
requests_version = "could not import"
except Exception as e:
requests_version = "Error %s" % e
try:
import conda_build
except ImportError:
conda_build_version = "not installed"
except Exception as e:
conda_build_version = "Error %s" % e
else:
conda_build_version = conda_build.__version__
# this is a hack associated with channel weight until we get the package cache reworked
# in a future release
# for now, just ordering the channels for display in a semi-plausible way
d = defaultdict(list)
any(d[v[1]].append(k) for k, v in iteritems(config.get_channel_urls()))
channels = list(chain.from_iterable(d[q] for q in sorted(d, reverse=True)))
info_dict = dict(
platform=config.subdir,
conda_version=conda.__version__,
conda_build_version=conda_build_version,
root_prefix=config.root_dir,
root_writable=config.root_writable,
pkgs_dirs=config.pkgs_dirs,
envs_dirs=config.envs_dirs,
default_prefix=config.default_prefix,
channels=channels,
rc_path=config.rc_path,
user_rc_path=config.user_rc_path,
sys_rc_path=config.sys_rc_path,
is_foreign=bool(config.foreign),
envs=[],
python_version='.'.join(map(str, sys.version_info)),
requests_version=requests_version,
)
if args.unsafe_channels:
if not args.json:
print("\n".join(info_dict["channels"]))
else:
print(json.dumps({"channels": info_dict["channels"]}))
return 0
else:
info_dict['channels'] = [config.hide_binstar_tokens(c) for c in
info_dict['channels']]
if args.all or args.json:
for option in options:
setattr(args, option, True)
if args.all or all(not getattr(args, opt) for opt in options):
for key in 'pkgs_dirs', 'envs_dirs', 'channels':
info_dict['_' + key] = ('\n' + 24 * ' ').join(info_dict[key])
info_dict['_rtwro'] = ('writable' if info_dict['root_writable'] else
'read only')
print("""\
Current conda install:
platform : %(platform)s
conda version : %(conda_version)s
conda-build version : %(conda_build_version)s
python version : %(python_version)s
requests version : %(requests_version)s
root environment : %(root_prefix)s (%(_rtwro)s)
default environment : %(default_prefix)s
envs directories : %(_envs_dirs)s
package cache : %(_pkgs_dirs)s
channel URLs : %(_channels)s
config file : %(rc_path)s
is foreign system : %(is_foreign)s
""" % info_dict)
if not is_initialized():
print("""\
# NOTE:
# root directory '%s' is uninitialized""" % config.root_dir)
if args.envs:
common.handle_envs_list(info_dict['envs'], not args.json)
if args.system and not args.json:
from conda.cli.find_commands import find_commands, find_executable
print("sys.version: %s..." % (sys.version[:40]))
print("sys.prefix: %s" % sys.prefix)
print("sys.executable: %s" % sys.executable)
print("conda location: %s" % dirname(conda.__file__))
for cmd in sorted(set(find_commands() + ['build'])):
print("conda-%s: %s" % (cmd, find_executable('conda-' + cmd)))
print("user site dirs: ", end='')
site_dirs = get_user_site()
if site_dirs:
print(site_dirs[0])
else:
print()
for site_dir in site_dirs[1:]:
print(' %s' % site_dir)
print()
evars = ['PATH', 'PYTHONPATH', 'PYTHONHOME', 'CONDA_DEFAULT_ENV',
'CIO_TEST', 'CONDA_ENVS_PATH']
if config.platform == 'linux':
evars.append('LD_LIBRARY_PATH')
elif config.platform == 'osx':
evars.append('DYLD_LIBRARY_PATH')
for ev in sorted(evars):
print("%s: %s" % (ev, os.getenv(ev, '<not set>')))
print()
if args.license and not args.json:
try:
from _license import show_info
show_info()
except ImportError:
print("""\
WARNING: could not import _license.show_info
# try:
# $ conda install -n root _license""")
if args.json:
common.stdout_json(info_dict)
def install(args, parser, command='install'):
"""
conda install, conda update, and conda create
"""
newenv = bool(command == 'create')
if newenv:
common.ensure_name_or_prefix(args, command)
prefix = common.get_prefix(args, search=not newenv)
if newenv:
check_prefix(prefix)
config.set_pkgs_dirs(prefix)
if command == 'update':
if args.all:
if args.packages:
sys.exit("""Error: --all cannot be used with packages""")
else:
if len(args.packages) == 0:
sys.exit("""Error: no package names supplied
# If you want to update to a newer version of Anaconda, type:
#
# $ conda update --prefix %s anaconda
""" % prefix)
if command == 'update':
linked = ci.linked(prefix)
for name in args.packages:
common.arg2spec(name)
if '=' in name:
sys.exit("Invalid package name: '%s'" % (name))
if name not in set(ci.name_dist(d) for d in linked):
sys.exit("Error: package '%s' is not installed in %s" %
(name, prefix))
if newenv and args.clone:
if args.packages:
sys.exit('Error: did not expect any arguments for --clone')
clone(args.clone, prefix)
touch_nonadmin(prefix)
print_activate(args.name if args.name else prefix)
return
if newenv and not args.no_default_packages:
default_packages = config.create_default_packages[:]
# Override defaults if they are specified at the command line
for default_pkg in config.create_default_packages:
if any(pkg.split('=')[0] == default_pkg for pkg in args.packages):
default_packages.remove(default_pkg)
args.packages.extend(default_packages)
common.ensure_override_channels_requires_channel(args)
channel_urls = args.channel or ()
if args.file:
specs = common.specs_from_url(args.file)
elif getattr(args, 'all', False):
specs = []
linked = ci.linked(prefix)
for pkg in linked:
name, ver, build = pkg.rsplit('-', 2)
if name == 'python' and ver.startswith('2'):
# Oh Python 2...
specs.append('%s >=%s,<3' % (name, ver))
else:
specs.append('%s >=%s' % (name, ver))
else:
specs = common.specs_from_args(args.packages)
if command == 'install' and args.revision:
get_revision(args.revision)
else:
common.check_specs(prefix, specs)
if args.use_local:
from conda.fetch import fetch_index
from conda.utils import url_path
try:
from conda_build import config as build_config
except ImportError:
sys.exit("Error: you need to have 'conda-build' installed"
" to use the --use-local option")
# remove the cache such that a refetch is made,
# this is necessary because we add the local build repo URL
fetch_index.cache = {}
index = get_index([url_path(build_config.croot)],
use_cache=args.use_index_cache,
unknown=args.unknown)
else:
index = get_index(channel_urls=channel_urls, prepend=not
args.override_channels,
use_cache=args.use_index_cache,
unknown=args.unknown)
# Don't update packages that are already up-to-date
if command == 'update' and not args.all:
r = Resolve(index)
orig_packages = args.packages[:]
for name in orig_packages:
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
build_inst = [dist.rsplit('-', 2)[2].rsplit('.tar.bz2', 1)[0]
for dist in linked
if dist.rsplit('-', 2)[0] == name]
assert len(vers_inst) == 1, name
assert len(build_inst) == 1, name
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
# Shouldn't happen?
continue
latest = pkgs[-1]
if latest.version == vers_inst[0] and latest.build == build_inst[0]:
args.packages.remove(name)
if not args.packages:
from conda.cli.main_list import list_packages
regex = '^(%s)$' % '|'.join(orig_packages)
print('# All requested packages already installed.')
list_packages(prefix, regex)
return
# handle tar file containing conda packages
if len(args.packages) == 1:
tar_path = args.packages[0]
if tar_path.endswith('.tar'):
install_tar(prefix, tar_path, verbose=not args.quiet)
return
# handle explicit installs of conda packages
if args.packages and all(s.endswith('.tar.bz2') for s in args.packages):
from conda.misc import install_local_packages
install_local_packages(prefix, args.packages, verbose=not args.quiet)
return
if any(s.endswith('.tar.bz2') for s in args.packages):
sys.exit("cannot mix specifications with conda package filenames")
if args.force:
args.no_deps = True
spec_names = set(s.split()[0] for s in specs)
if args.no_deps:
only_names = spec_names
else:
only_names = None
if not isdir(prefix) and not newenv:
if args.mkdir:
try:
os.makedirs(prefix)
except OSError:
sys.exit("Error: could not create directory: %s" % prefix)
else:
sys.exit("""\
Error: environment does not exist: %s
#
# Use 'conda create' to create an environment before installing packages
# into it.
#""" % prefix)
if command == 'install' and args.revision:
actions = plan.revert_actions(prefix, get_revision(args.revision))
else:
actions = plan.install_actions(prefix, index, specs, force=args.force,
only_names=only_names)
if plan.nothing_to_do(actions):
from conda.cli.main_list import list_packages
regex = '^(%s)$' % '|'.join(spec_names)
print('# All requested packages already installed.')
list_packages(prefix, regex)
return
print()
print("Package plan for installation in environment %s:" % prefix)
plan.display_actions(actions, index)
if command in {'install', 'update'}:
common.check_write(command, prefix)
if not pscheck.main(args):
common.confirm_yn(args)
plan.execute_actions(actions, index, verbose=not args.quiet)
if newenv:
touch_nonadmin(prefix)
print_activate(args.name if args.name else prefix)
def execute(args, parser):
import os
from os.path import dirname
import conda
from conda.base.context import context
from conda.models.channel import offline_keep
from conda.resolve import Resolve
from conda.api import get_index
from conda.connection import user_agent
if args.root:
if context.json:
stdout_json({'root_prefix': context.root_dir})
else:
print(context.root_dir)
return
if args.packages:
index = get_index()
r = Resolve(index)
if context.json:
stdout_json({
package: [p._asdict()
for p in sorted(r.get_pkgs(arg2spec(package)))]
for package in args.packages
})
else:
for package in args.packages:
versions = r.get_pkgs(arg2spec(package))
for pkg in sorted(versions):
pretty_package(pkg)
return
options = 'envs', 'system', 'license'
try:
from conda.install import linked_data
root_pkgs = linked_data(sys.prefix)
except:
root_pkgs = None
try:
import requests
requests_version = requests.__version__
except ImportError:
requests_version = "could not import"
except Exception as e:
requests_version = "Error %s" % e
try:
import conda_env
conda_env_version = conda_env.__version__
except:
try:
cenv = [p for p in itervalues(root_pkgs) if p['name'] == 'conda-env']
conda_env_version = cenv[0]['version']
except:
conda_env_version = "not installed"
try:
import conda_build
except ImportError:
conda_build_version = "not installed"
except Exception as e:
conda_build_version = "Error %s" % e
else:
conda_build_version = conda_build.__version__
channels = context.channels
if args.unsafe_channels:
if not context.json:
print("\n".join(channels))
else:
print(json.dumps({"channels": channels}))
return 0
channels = list(prioritize_channels(channels).keys())
if not context.json:
channels = [c + ('' if offline_keep(c) else ' (offline)')
for c in channels]
channels = [mask_anaconda_token(c) for c in channels]
info_dict = dict(
platform=context.subdir,
conda_version=conda.__version__,
conda_env_version=conda_env_version,
conda_build_version=conda_build_version,
root_prefix=context.root_dir,
conda_prefix=context.conda_prefix,
conda_private=context.conda_private,
root_writable=context.root_writable,
pkgs_dirs=context.pkgs_dirs,
envs_dirs=context.envs_dirs,
default_prefix=context.default_prefix,
channels=channels,
rc_path=rc_path,
user_rc_path=user_rc_path,
sys_rc_path=sys_rc_path,
# is_foreign=bool(foreign),
offline=context.offline,
envs=[],
python_version='.'.join(map(str, sys.version_info)),
requests_version=requests_version,
user_agent=user_agent,
)
if not on_win:
info_dict['UID'] = os.geteuid()
info_dict['GID'] = os.getegid()
if args.all or context.json:
for option in options:
setattr(args, option, True)
if args.all or all(not getattr(args, opt) for opt in options):
for key in 'pkgs_dirs', 'envs_dirs', 'channels':
info_dict['_' + key] = ('\n' + 26 * ' ').join(info_dict[key])
info_dict['_rtwro'] = ('writable' if info_dict['root_writable'] else
'read only')
print("""\
Current conda install:
platform : %(platform)s
conda version : %(conda_version)s
conda is private : %(conda_private)s
conda-env version : %(conda_env_version)s
conda-build version : %(conda_build_version)s
python version : %(python_version)s
requests version : %(requests_version)s
root environment : %(root_prefix)s (%(_rtwro)s)
default environment : %(default_prefix)s
envs directories : %(_envs_dirs)s
package cache : %(_pkgs_dirs)s
channel URLs : %(_channels)s
config file : %(rc_path)s
offline mode : %(offline)s
user-agent : %(user_agent)s\
""" % info_dict)
if not on_win:
print("""\
UID:GID : %(UID)s:%(GID)s
""" % info_dict)
else:
print()
if args.envs:
handle_envs_list(info_dict['envs'], not context.json)
if args.system:
from conda.cli.find_commands import find_commands, find_executable
site_dirs = get_user_site()
evars = ['PATH', 'PYTHONPATH', 'PYTHONHOME', 'CONDA_DEFAULT_ENV',
'CIO_TEST', 'CONDA_ENVS_PATH']
if context.platform == 'linux':
evars.append('LD_LIBRARY_PATH')
elif context.platform == 'osx':
evars.append('DYLD_LIBRARY_PATH')
if context.json:
info_dict['sys.version'] = sys.version
info_dict['sys.prefix'] = sys.prefix
info_dict['sys.executable'] = sys.executable
info_dict['site_dirs'] = get_user_site()
info_dict['env_vars'] = {ev: os.getenv(ev, '<not set>') for ev in evars}
else:
print("sys.version: %s..." % (sys.version[:40]))
print("sys.prefix: %s" % sys.prefix)
print("sys.executable: %s" % sys.executable)
print("conda location: %s" % dirname(conda.__file__))
for cmd in sorted(set(find_commands() + ['build'])):
print("conda-%s: %s" % (cmd, find_executable('conda-' + cmd)))
print("user site dirs: ", end='')
if site_dirs:
print(site_dirs[0])
else:
print()
for site_dir in site_dirs[1:]:
print(' %s' % site_dir)
print()
for ev in sorted(evars):
print("%s: %s" % (ev, os.getenv(ev, '<not set>')))
print()
if args.license and not context.json:
try:
from _license import show_info
show_info()
except ImportError:
print("""\
WARNING: could not import _license.show_info
# try:
# $ conda install -n root _license""")
if context.json:
stdout_json(info_dict)
def execute_search(args, parser):
import re
from conda.resolve import MatchSpec, Resolve
if args.reverse_dependency:
if not args.regex:
parser.error("--reverse-dependency requires at least one package name")
if args.spec:
parser.error("--reverse-dependency does not work with --spec")
pat = None
ms = None
if args.regex:
if args.spec:
ms = MatchSpec(' '.join(args.regex.split('=')))
else:
regex = args.regex
if args.full_name:
regex = r'^%s$' % regex
try:
pat = re.compile(regex, re.I)
except re.error as e:
common.error_and_exit(
"'%s' is not a valid regex pattern (exception: %s)" %
(regex, e),
json=args.json,
error_type="ValueError")
prefix = common.get_prefix(args)
import conda.config
import conda.install
linked = conda.install.linked(prefix)
extracted = set()
for pkgs_dir in conda.config.pkgs_dirs:
extracted.update(conda.install.extracted(pkgs_dir))
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != config.subdir:
args.unknown = False
common.ensure_override_channels_requires_channel(args, dashc=False,
json=args.json)
channel_urls = args.channel or ()
if args.use_local:
from conda.fetch import fetch_index
from conda.utils import url_path
try:
from conda_build.config import croot
except ImportError:
common.error_and_exit("you need to have 'conda-build >= 1.7.1' installed"
" to use the --use-local option",
json=args.json,
error_type="RuntimeError")
# remove the cache such that a refetch is made,
# this is necessary because we add the local build repo URL
fetch_index.cache = {}
index = common.get_index_trap(channel_urls=[url_path(croot)] + list(channel_urls),
prepend=not args.override_channels,
use_cache=args.use_index_cache,
unknown=args.unknown,
json=args.json, platform=args.platform, offline=args.offline)
else:
index = common.get_index_trap(channel_urls=channel_urls, prepend=not
args.override_channels, platform=args.platform,
use_cache=args.use_index_cache,
unknown=args.unknown, json=args.json, offline=args.offline)
r = Resolve(index)
if args.canonical:
json = []
else:
json = {}
names = []
for name in sorted(r.groups):
if args.reverse_dependency:
ms_name = ms
for pkg in r.groups[name]:
for dep in r.ms_depends(pkg):
if pat.search(dep.name):
names.append((name, Package(pkg, r.index[pkg])))
else:
if pat and pat.search(name) is None:
continue
if ms and name != ms.name:
continue
if ms:
ms_name = ms
else:
ms_name = MatchSpec(name)
pkgs = sorted(r.get_pkgs(ms_name))
names.append((name, pkgs))
if args.reverse_dependency:
new_names = []
old = None
for name, pkg in sorted(names, key=lambda x:(x[0], x[1].name, x[1])):
if name == old:
new_names[-1][1].append(pkg)
else:
new_names.append((name, [pkg]))
old = name
names = new_names
for name, pkgs in names:
if args.reverse_dependency:
disp_name = pkgs[0].name
else:
disp_name = name
if args.names_only and not args.outdated:
print(name)
continue
if not args.canonical:
json[name] = []
if args.outdated:
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
if args.names_only:
print(name)
continue
for pkg in pkgs:
dist = pkg.fn[:-8]
if args.canonical:
if not args.json:
print(dist)
else:
json.append(dist)
continue
if platform and platform != config.subdir:
inst = ' '
elif dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
if not args.json:
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name, inst,
pkg.version,
pkg.build,
config.canonical_channel_name(pkg.channel),
common.disp_features(r.features(pkg.fn)),
))
disp_name = ''
else:
data = {}
data.update(pkg.info)
data.update({
'fn': pkg.fn,
'installed': inst == '*',
'extracted': inst in '*.',
'version': pkg.version,
'build': pkg.build,
'build_number': pkg.build_number,
'channel': config.canonical_channel_name(pkg.channel),
'full_channel': pkg.channel,
'features': list(r.features(pkg.fn)),
'license': pkg.info.get('license'),
'size': pkg.info.get('size'),
'depends': pkg.info.get('depends'),
'type': pkg.info.get('type')
})
if data['type'] == 'app':
data['icon'] = make_icon_url(pkg.info)
json[name].append(data)
if args.json:
common.stdout_json(json)
def execute(args, parser):
import os
from os.path import basename, dirname
import conda
import conda.config as config
import conda.misc as misc
from conda.resolve import Resolve, MatchSpec
from conda.cli.main_init import is_initialized
from conda.api import get_index, get_package_versions
if args.root:
if args.json:
common.stdout_json({'root_prefix': config.root_dir})
else:
print(config.root_dir)
return
if args.packages:
if args.json:
results = defaultdict(list)
for arg in args.packages:
for pkg in get_package_versions(arg):
results[arg].append(pkg._asdict())
common.stdout_json(results)
return
index = get_index()
r = Resolve(index)
specs = map(common.arg2spec, args.packages)
for spec in specs:
versions = r.get_pkgs(MatchSpec(spec))
for pkg in versions:
pretty_package(pkg)
return
options = 'envs', 'system', 'license'
try:
import requests
requests_version = requests.__version__
except ImportError:
requests_version = "could not import"
except Exception as e:
requests_version = "Error %s" % e
try:
import conda_build
except ImportError:
conda_build_version = "not installed"
except Exception as e:
conda_build_version = "Error %s" % e
else:
conda_build_version = conda_build.__version__
info_dict = dict(platform=config.subdir,
conda_version=conda.__version__,
conda_build_version=conda_build_version,
root_prefix=config.root_dir,
root_writable=config.root_writable,
pkgs_dirs=config.pkgs_dirs,
envs_dirs=config.envs_dirs,
default_prefix=config.default_prefix,
channels=config.get_channel_urls(),
rc_path=config.rc_path,
user_rc_path=config.user_rc_path,
sys_rc_path=config.sys_rc_path,
is_foreign=bool(config.foreign),
envs=[],
python_version='.'.join(map(str, sys.version_info)),
requests_version=requests_version,
)
if args.all or args.json:
for option in options:
setattr(args, option, True)
info_dict['channels'] = [config.hide_binstar_tokens(c) for c in
info_dict['channels']]
if args.all or all(not getattr(args, opt) for opt in options):
for key in 'pkgs_dirs', 'envs_dirs', 'channels':
info_dict['_' + key] = ('\n' + 24 * ' ').join(info_dict[key])
info_dict['_rtwro'] = ('writable' if info_dict['root_writable'] else
'read only')
print("""\
Current conda install:
platform : %(platform)s
conda version : %(conda_version)s
conda-build version : %(conda_build_version)s
python version : %(python_version)s
requests version : %(requests_version)s
root environment : %(root_prefix)s (%(_rtwro)s)
default environment : %(default_prefix)s
envs directories : %(_envs_dirs)s
package cache : %(_pkgs_dirs)s
channel URLs : %(_channels)s
config file : %(rc_path)s
is foreign system : %(is_foreign)s
""" % info_dict)
if not is_initialized():
print("""\
# NOTE:
# root directory '%s' is uninitialized""" % config.root_dir)
if args.envs:
common.handle_envs_list(info_dict['envs'], not args.json)
if args.system and not args.json:
from conda.cli.find_commands import find_commands, find_executable
print("sys.version: %s..." % (sys.version[:40]))
print("sys.prefix: %s" % sys.prefix)
print("sys.executable: %s" % sys.executable)
print("conda location: %s" % dirname(conda.__file__))
for cmd in sorted(set(find_commands() + ['build'])):
print("conda-%s: %s" % (cmd, find_executable('conda-' + cmd)))
print("user site dirs: ", end='')
site_dirs = get_user_site()
if site_dirs:
print(site_dirs[0])
else:
print()
for site_dir in site_dirs[1:]:
print(' %s' % site_dir)
print()
evars = ['PATH', 'PYTHONPATH', 'PYTHONHOME', 'CONDA_DEFAULT_ENV',
'CIO_TEST', 'CONDA_ENVS_PATH']
if config.platform == 'linux':
evars.append('LD_LIBRARY_PATH')
elif config.platform == 'osx':
evars.append('DYLD_LIBRARY_PATH')
for ev in sorted(evars):
print("%s: %s" % (ev, os.getenv(ev, '<not set>')))
print()
if args.license and not args.json:
try:
from _license import show_info
show_info()
except ImportError:
print("""\
WARNING: could not import _license.show_info
# try:
# $ conda install -n root _license""")
if args.json:
common.stdout_json(info_dict)
def get_package_versions(package, offline=False):
index = get_index(offline=offline)
r = Resolve(index)
return r.get_pkgs(package, emptyok=True)
def execute_search(args, parser):
import re
import sys
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
pat = None
ms = None
if args.regex:
if args.spec:
ms = MatchSpec(' '.join(args.regex.split('=')))
else:
try:
pat = re.compile(args.regex, re.I)
except re.error as e:
common.error_and_exit("%r is not a valid regex pattern (exception: %s)" %
(args.regex, e),
json=args.json,
error_type="ValueError")
prefix = common.get_prefix(args)
if not args.canonical:
import conda.config
import conda.install
linked = conda.install.linked(prefix)
extracted = set()
for pkgs_dir in conda.config.pkgs_dirs:
extracted.update(conda.install.extracted(pkgs_dir))
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != config.subdir:
args.unknown = False
common.ensure_override_channels_requires_channel(args, dashc=False,
json=args.json)
channel_urls = args.channel or ()
index = common.get_index_trap(channel_urls=channel_urls, prepend=not
args.override_channels, platform=args.platform,
use_cache=args.use_index_cache,
unknown=args.unknown, json=args.json)
r = Resolve(index)
if args.canonical:
json = []
else:
json = {}
for name in sorted(r.groups):
disp_name = name
if pat and pat.search(name) is None:
continue
if ms and name != ms.name:
continue
if ms:
ms_name = ms
else:
ms_name = MatchSpec(name)
if not args.canonical:
json[name] = []
if args.outdated:
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
pkgs = sorted(r.get_pkgs(ms_name))
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
for pkg in sorted(r.get_pkgs(ms_name)):
dist = pkg.fn[:-8]
if args.canonical:
if not args.json:
print(dist)
else:
json.append(dist)
continue
if dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
if not args.json:
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name, inst,
pkg.version,
pkg.build,
config.canonical_channel_name(pkg.channel),
common.disp_features(r.features(pkg.fn)),
))
disp_name = ''
else:
data = {}
data.update(pkg.info)
data.update({
'fn': pkg.fn,
'installed': inst == '*',
'extracted': inst in '*.',
'version': pkg.version,
'build': pkg.build,
'build_number': pkg.build_number,
'channel': config.canonical_channel_name(pkg.channel),
'full_channel': pkg.channel,
'features': list(r.features(pkg.fn)),
'license': pkg.info.get('license'),
'size': pkg.info.get('size'),
'depends': pkg.info.get('depends'),
'type': pkg.info.get('type')
})
if data['type'] == 'app':
data['icon'] = make_icon_url(pkg.info)
json[name].append(data)
if args.json:
common.stdout_json(json)
def install(args, parser, command='install'):
"""
conda install, conda update, and conda create
"""
newenv = bool(command == 'create')
if newenv:
common.ensure_name_or_prefix(args, command)
prefix = common.get_prefix(args, search=not newenv)
if newenv:
check_prefix(prefix, json=args.json)
if config.force_32bit and plan.is_root_prefix(prefix):
common.error_and_exit("cannot use CONDA_FORCE_32BIT=1 in root env")
if command == 'update':
if not args.file:
if not args.all and len(args.packages) == 0:
common.error_and_exit("""no package names supplied
# If you want to update to a newer version of Anaconda, type:
#
# $ conda update --prefix %s anaconda
""" % prefix,
json=args.json,
error_type="ValueError")
if command == 'update' and not args.all:
linked = ci.linked(prefix)
for name in args.packages:
common.arg2spec(name, json=args.json)
if '=' in name:
common.error_and_exit("Invalid package name: '%s'" % (name),
json=args.json,
error_type="ValueError")
if name not in set(ci.name_dist(d) for d in linked):
common.error_and_exit("package '%s' is not installed in %s" %
(name, prefix),
json=args.json,
error_type="ValueError")
if newenv and not args.no_default_packages:
default_packages = config.create_default_packages[:]
# Override defaults if they are specified at the command line
for default_pkg in config.create_default_packages:
if any(pkg.split('=')[0] == default_pkg for pkg in args.packages):
default_packages.remove(default_pkg)
args.packages.extend(default_packages)
else:
default_packages = []
common.ensure_override_channels_requires_channel(args)
channel_urls = args.channel or ()
specs = []
if args.file:
for fpath in args.file:
specs.extend(common.specs_from_url(fpath, json=args.json))
elif getattr(args, 'all', False):
linked = ci.linked(prefix)
if not linked:
common.error_and_exit("There are no packages installed in the "
"prefix %s" % prefix)
for pkg in linked:
name, ver, build = pkg.rsplit('-', 2)
if name in getattr(args, '_skip', ['anaconda']):
continue
if name == 'python' and ver.startswith('2'):
# Oh Python 2...
specs.append('%s >=%s,<3' % (name, ver))
else:
specs.append('%s' % name)
specs.extend(common.specs_from_args(args.packages, json=args.json))
if command == 'install' and args.revision:
get_revision(args.revision, json=args.json)
elif not (newenv and args.clone):
common.check_specs(prefix, specs, json=args.json,
create=(command == 'create'))
num_cp = sum(s.endswith('.tar.bz2') for s in args.packages)
if num_cp:
if num_cp == len(args.packages):
depends = misc.install_local_packages(prefix, args.packages,
verbose=not args.quiet)
if args.no_deps:
depends = []
specs = list(set(depends))
args.unknown = True
else:
common.error_and_exit(
"cannot mix specifications with conda package filenames",
json=args.json,
error_type="ValueError")
# handle tar file containing conda packages
if len(args.packages) == 1:
tar_path = args.packages[0]
if tar_path.endswith('.tar'):
depends = install_tar(prefix, tar_path, verbose=not args.quiet)
if args.no_deps:
depends = []
specs = list(set(depends))
args.unknown = True
if args.use_local:
from conda.fetch import fetch_index
from conda.utils import url_path
try:
from conda_build.config import croot
except ImportError:
common.error_and_exit(
"you need to have 'conda-build >= 1.7.1' installed"
" to use the --use-local option",
json=args.json,
error_type="RuntimeError")
# remove the cache such that a refetch is made,
# this is necessary because we add the local build repo URL
fetch_index.cache = {}
if exists(croot):
channel_urls = [url_path(croot)] + list(channel_urls)
index = common.get_index_trap(channel_urls=channel_urls,
prepend=not args.override_channels,
use_cache=args.use_index_cache,
unknown=args.unknown,
json=args.json,
offline=args.offline)
if newenv and args.clone:
if set(args.packages) - set(default_packages):
common.error_and_exit('did not expect any arguments for --clone',
json=args.json,
error_type="ValueError")
clone(args.clone, prefix, json=args.json, quiet=args.quiet, index=index)
misc.append_env(prefix)
misc.touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
return
# Don't update packages that are already up-to-date
if command == 'update' and not (args.all or args.force):
r = Resolve(index)
orig_packages = args.packages[:]
for name in orig_packages:
installed_metadata = [ci.is_linked(prefix, dist)
for dist in linked]
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
build_inst = [m['build_number'] for m in installed_metadata if
m['name'] == name]
try:
assert len(vers_inst) == 1, name
assert len(build_inst) == 1, name
except AssertionError as e:
if args.json:
common.exception_and_exit(e, json=True)
else:
raise
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
# Shouldn't happen?
continue
latest = pkgs[-1]
if (latest.version == vers_inst[0] and
latest.build_number == build_inst[0]):
args.packages.remove(name)
if not args.packages:
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(orig_packages)
print('# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(
message='All requested packages already installed.')
return
if args.force:
args.no_deps = True
spec_names = set(s.split()[0] for s in specs)
if args.no_deps:
only_names = spec_names
else:
only_names = None
if not isdir(prefix) and not newenv:
if args.mkdir:
try:
os.makedirs(prefix)
except OSError:
common.error_and_exit("Error: could not create directory: %s" % prefix,
json=args.json,
error_type="OSError")
else:
common.error_and_exit("""\
environment does not exist: %s
#
# Use 'conda create' to create an environment before installing packages
# into it.
#""" % prefix,
json=args.json,
error_type="NoEnvironmentFound")
try:
if command == 'install' and args.revision:
actions = plan.revert_actions(prefix, get_revision(args.revision))
else:
with common.json_progress_bars(json=args.json and not args.quiet):
actions = plan.install_actions(prefix, index, specs,
force=args.force,
only_names=only_names,
pinned=args.pinned,
minimal_hint=args.alt_hint,
update_deps=args.update_deps)
if config.always_copy or args.copy:
new_link = []
for pkg in actions["LINK"]:
dist, pkgs_dir, lt = inst.split_linkarg(pkg)
lt = ci.LINK_COPY
new_link.append("%s %s %d" % (dist, pkgs_dir, lt))
actions["LINK"] = new_link
except NoPackagesFound as e:
error_message = e.args[0]
if command == 'update' and args.all:
# Packages not found here just means they were installed but
# cannot be found any more. Just skip them.
if not args.json:
print("Warning: %s, skipping" % error_message)
else:
# Not sure what to do here
pass
args._skip = getattr(args, '_skip', ['anaconda'])
for pkg in e.pkgs:
p = pkg.split()[0]
if p in args._skip:
# Avoid infinite recursion. This can happen if a spec
# comes from elsewhere, like --file
raise
args._skip.append(p)
return install(args, parser, command=command)
else:
packages = {index[fn]['name'] for fn in index}
for pkg in e.pkgs:
close = get_close_matches(pkg, packages, cutoff=0.7)
if close:
error_message += ("\n\nDid you mean one of these?"
"\n\n %s" % (', '.join(close)))
error_message += '\n\nYou can search for this package on anaconda.org with'
error_message += '\n\n anaconda search -t conda %s' % pkg
if len(e.pkgs) > 1:
# Note this currently only happens with dependencies not found
error_message += '\n\n (and similarly for the other packages)'
if not find_executable('anaconda', include_others=False):
error_message += '\n\nYou may need to install the anaconda-client command line client with'
error_message += '\n\n conda install anaconda-client'
pinned_specs = plan.get_pinned_specs(prefix)
if pinned_specs:
error_message += "\n\nNote that you have pinned specs in %s:" % join(prefix, 'conda-meta', 'pinned')
error_message += "\n\n %r" % pinned_specs
common.error_and_exit(error_message, json=args.json)
except SystemExit as e:
# Unsatisfiable package specifications/no such revision/import error
error_type = 'UnsatisfiableSpecifications'
if e.args and 'could not import' in e.args[0]:
error_type = 'ImportError'
common.exception_and_exit(e, json=args.json, newline=True,
error_text=False,
error_type=error_type)
if plan.nothing_to_do(actions):
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(spec_names)
print('\n# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(
message='All requested packages already installed.')
return
if not args.json:
print()
print("Package plan for installation in environment %s:" % prefix)
plan.display_actions(actions, index, show_channel_urls=args.show_channel_urls)
if command in {'install', 'update'}:
common.check_write(command, prefix)
if not args.json:
common.confirm_yn(args)
elif args.dry_run:
common.stdout_json_success(actions=actions, dry_run=True)
sys.exit(0)
with common.json_progress_bars(json=args.json and not args.quiet):
try:
plan.execute_actions(actions, index, verbose=not args.quiet)
if not (command == 'update' and args.all):
try:
with open(join(prefix, 'conda-meta', 'history'), 'a') as f:
f.write('# %s specs: %s\n' % (command, specs))
except IOError as e:
if e.errno == errno.EACCES:
log.debug("Can't write the history file")
else:
raise
except RuntimeError as e:
if len(e.args) > 0 and "LOCKERROR" in e.args[0]:
error_type = "AlreadyLocked"
else:
error_type = "RuntimeError"
common.exception_and_exit(e, error_type=error_type, json=args.json)
except SystemExit as e:
common.exception_and_exit(e, json=args.json)
if newenv:
misc.append_env(prefix)
misc.touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
if args.json:
common.stdout_json_success(actions=actions)
def install(args, parser, command='install'):
"""
conda install, conda update, and conda create
"""
newenv = bool(command == 'create')
if newenv:
common.ensure_name_or_prefix(args, command)
prefix = common.get_prefix(args, search=not newenv)
if newenv:
check_prefix(prefix, json=args.json)
if command == 'update':
if args.all:
if args.packages:
common.error_and_exit("""--all cannot be used with packages""",
json=args.json,
error_type="ValueError")
else:
if len(args.packages) == 0:
common.error_and_exit("""no package names supplied
# If you want to update to a newer version of Anaconda, type:
#
# $ conda update --prefix %s anaconda
""" % prefix,
json=args.json,
error_type="ValueError")
if command == 'update':
linked = ci.linked(prefix)
for name in args.packages:
common.arg2spec(name, json=args.json)
if '=' in name:
common.error_and_exit("Invalid package name: '%s'" % (name),
json=args.json,
error_type="ValueError")
if name not in set(ci.name_dist(d) for d in linked):
common.error_and_exit("package '%s' is not installed in %s" %
(name, prefix),
json=args.json,
error_type="ValueError")
if newenv and args.clone:
if args.packages:
common.error_and_exit('did not expect any arguments for --clone',
json=args.json,
error_type="ValueError")
clone(args.clone, prefix, json=args.json, quiet=args.quiet)
touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
return
if newenv and not args.no_default_packages:
default_packages = config.create_default_packages[:]
# Override defaults if they are specified at the command line
for default_pkg in config.create_default_packages:
if any(pkg.split('=')[0] == default_pkg for pkg in args.packages):
default_packages.remove(default_pkg)
args.packages.extend(default_packages)
common.ensure_override_channels_requires_channel(args)
channel_urls = args.channel or ()
specs = []
if args.file:
specs.extend(common.specs_from_url(args.file, json=args.json))
elif getattr(args, 'all', False):
linked = ci.linked(prefix)
for pkg in linked:
name, ver, build = pkg.rsplit('-', 2)
if name == 'python' and ver.startswith('2'):
# Oh Python 2...
specs.append('%s >=%s,<3' % (name, ver))
else:
specs.append('%s >=%s' % (name, ver))
specs.extend(common.specs_from_args(args.packages, json=args.json))
if command == 'install' and args.revision:
get_revision(args.revision, json=args.json)
else:
common.check_specs(prefix, specs, json=args.json)
if args.use_local:
from conda.fetch import fetch_index
from conda.utils import url_path
try:
from conda_build import config as build_config
except ImportError:
common.error_and_exit(
"you need to have 'conda-build' installed"
" to use the --use-local option",
json=args.json,
error_type="RuntimeError")
# remove the cache such that a refetch is made,
# this is necessary because we add the local build repo URL
fetch_index.cache = {}
index = common.get_index_trap([url_path(build_config.croot)],
use_cache=args.use_index_cache,
unknown=args.unknown,
json=args.json)
else:
index = common.get_index_trap(channel_urls=channel_urls,
prepend=not args.override_channels,
use_cache=args.use_index_cache,
unknown=args.unknown,
json=args.json)
# Don't update packages that are already up-to-date
if command == 'update' and not args.all:
r = Resolve(index)
orig_packages = args.packages[:]
for name in orig_packages:
installed_metadata = [
ci.is_linked(prefix, dist) for dist in linked
]
vers_inst = [
dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name
]
build_inst = [
m['build_number'] for m in installed_metadata
if m['name'] == name
]
try:
assert len(vers_inst) == 1, name
assert len(build_inst) == 1, name
except AssertionError as e:
if args.json:
common.exception_and_exit(e, json=True)
else:
raise
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
# Shouldn't happen?
continue
latest = pkgs[-1]
if latest.version == vers_inst[
0] and latest.build_number == build_inst[0]:
args.packages.remove(name)
if not args.packages:
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(orig_packages)
print('# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(
message='All requested packages already installed.')
return
# handle tar file containing conda packages
if len(args.packages) == 1:
tar_path = args.packages[0]
if tar_path.endswith('.tar'):
install_tar(prefix, tar_path, verbose=not args.quiet)
return
# handle explicit installs of conda packages
if args.packages and all(s.endswith('.tar.bz2') for s in args.packages):
from conda.misc import install_local_packages
install_local_packages(prefix, args.packages, verbose=not args.quiet)
return
if any(s.endswith('.tar.bz2') for s in args.packages):
common.error_and_exit(
"cannot mix specifications with conda package filenames",
json=args.json,
error_type="ValueError")
if args.force:
args.no_deps = True
spec_names = set(s.split()[0] for s in specs)
if args.no_deps:
only_names = spec_names
else:
only_names = None
if not isdir(prefix) and not newenv:
if args.mkdir:
try:
os.makedirs(prefix)
except OSError:
common.error_and_exit("Error: could not create directory: %s" %
prefix,
json=args.json,
error_type="OSError")
else:
common.error_and_exit("""\
environment does not exist: %s
#
# Use 'conda create' to create an environment before installing packages
# into it.
#""" % prefix,
json=args.json,
error_type="NoEnvironmentFound")
try:
if command == 'install' and args.revision:
actions = plan.revert_actions(prefix, get_revision(args.revision))
else:
actions = plan.install_actions(prefix,
index,
specs,
force=args.force,
only_names=only_names,
pinned=args.pinned,
minimal_hint=args.alt_hint)
except NoPackagesFound as e:
error_message = e.args[0]
packages = {index[fn]['name'] for fn in index}
for pkg in e.pkgs:
close = get_close_matches(pkg, packages)
if close:
error_message += "\n\nDid you mean one of these?\n %s" % (
', '.join(close))
error_message += '\n\nYou can search for this package on Binstar with'
error_message += '\n\n binstar search -t conda %s' % pkg
error_message += '\n\nYou may need to install the Binstar command line client with'
error_message += '\n\n conda install binstar'
common.error_and_exit(error_message, json=args.json)
except SystemExit as e:
# Unsatisfiable package specifications/no such revision/import error
error_type = 'UnsatisfiableSpecifications'
if e.args and 'could not import' in e.args[0]:
error_type = 'ImportError'
common.exception_and_exit(e,
json=args.json,
newline=True,
error_text=False,
error_type=error_type)
if plan.nothing_to_do(actions):
from conda.cli.main_list import print_packages
if not args.json:
regex = '^(%s)$' % '|'.join(spec_names)
print('\n# All requested packages already installed.')
print_packages(prefix, regex)
else:
common.stdout_json_success(
message='All requested packages already installed.')
return
if not args.json:
print()
print("Package plan for installation in environment %s:" % prefix)
plan.display_actions(actions, index)
if command in {'install', 'update'}:
common.check_write(command, prefix)
if not args.json:
if not pscheck.main(args):
common.confirm_yn(args)
else:
if (sys.platform == 'win32' and not args.force_pscheck
and not pscheck.check_processes(verbose=False)):
common.error_and_exit(
"Cannot continue operation while processes "
"from packages are running without --force-pscheck.",
json=True,
error_type="ProcessesStillRunning")
elif args.dry_run:
common.stdout_json_success(actions=actions, dry_run=True)
sys.exit(0)
with common.json_progress_bars(json=args.json and not args.quiet):
try:
plan.execute_actions(actions, index, verbose=not args.quiet)
except RuntimeError as e:
if len(e.args) > 0 and "LOCKERROR" in e.args[0]:
error_type = "AlreadyLocked"
else:
error_type = "RuntimeError"
common.exception_and_exit(e, error_type=error_type, json=args.json)
except SystemExit as e:
common.exception_and_exit(e, json=args.json)
if newenv:
touch_nonadmin(prefix)
if not args.json:
print_activate(args.name if args.name else prefix)
if args.json:
common.stdout_json_success(actions=actions)
def execute_search(args, parser):
import re
from conda.resolve import Resolve
if args.reverse_dependency:
if not args.regex:
parser.error(
"--reverse-dependency requires at least one package name")
if args.spec:
parser.error("--reverse-dependency does not work with --spec")
pat = None
ms = None
if args.regex:
if args.spec:
ms = ' '.join(args.regex.split('='))
else:
regex = args.regex
if args.full_name:
regex = r'^%s$' % regex
try:
pat = re.compile(regex, re.I)
except re.error as e:
raise CommandArgumentError(
"Failed to compile regex pattern for "
"search: %(regex)s\n"
"regex error: %(regex_error)s",
regex=regex,
regex_error=repr(e))
prefix = context.prefix_w_legacy_search
from ..core.linked_data import linked as linked_data
from ..core.package_cache import PackageCache
linked = linked_data(prefix)
extracted = set(pc_entry.dist.name
for pc_entry in PackageCache.get_all_extracted_entries())
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != context.subdir:
args.unknown = False
ensure_use_local(args)
ensure_override_channels_requires_channel(args, dashc=False)
channel_urls = args.channel or ()
index = get_index(channel_urls=channel_urls,
prepend=not args.override_channels,
platform=args.platform,
use_local=args.use_local,
use_cache=args.use_index_cache,
prefix=None,
unknown=args.unknown)
r = Resolve(index)
if args.canonical:
json = []
else:
json = {}
names = []
for name in sorted(r.groups):
if '@' in name:
continue
if args.reverse_dependency:
ms_name = ms
for pkg in r.groups[name]:
for dep in r.ms_depends(pkg):
if pat.search(dep.name):
names.append((name, Package(pkg, r.index[pkg])))
else:
if pat and pat.search(name) is None:
continue
if ms and name != ms.split()[0]:
continue
if ms:
ms_name = ms
else:
ms_name = name
pkgs = sorted(r.get_pkgs(ms_name))
names.append((name, pkgs))
if args.reverse_dependency:
new_names = []
old = None
for name, pkg in sorted(names, key=lambda x: (x[0], x[1].name, x[1])):
if name == old:
new_names[-1][1].append(pkg)
else:
new_names.append((name, [pkg]))
old = name
names = new_names
for name, pkgs in names:
if args.reverse_dependency:
disp_name = pkgs[0].name
else:
disp_name = name
if args.names_only and not args.outdated:
print(name)
continue
if not args.canonical:
json[name] = []
if args.outdated:
vers_inst = [
dist.quad[1] for dist in linked if dist.quad[0] == name
]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
if args.names_only:
print(name)
continue
for pkg in pkgs:
dist = Dist(pkg)
if args.canonical:
if not context.json:
print(dist.dist_name)
else:
json.append(dist.dist_name)
continue
if platform and platform != context.subdir:
inst = ' '
elif dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
features = r.features(dist)
if not context.json:
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name,
inst,
pkg.version,
pkg.build,
pkg.schannel,
disp_features(features),
))
disp_name = ''
else:
data = {}
data.update(pkg.info.dump())
data.update({
'fn': pkg.fn,
'installed': inst == '*',
'extracted': inst in '*.',
'version': pkg.version,
'build': pkg.build,
'build_number': pkg.build_number,
'channel': pkg.schannel,
'full_channel': pkg.channel,
'features': list(features),
'license': pkg.info.get('license'),
'size': pkg.info.get('size'),
'depends': pkg.info.get('depends'),
'type': pkg.info.get('type')
})
if data['type'] == 'app':
data['icon'] = make_icon_url(pkg.info)
json[name].append(data)
if context.json:
stdout_json(json)
def execute(args, parser):
import os
from os.path import dirname
import conda
import conda.config as config
from conda.resolve import Resolve
from conda.cli.main_init import is_initialized
from conda.api import get_index, get_package_versions
if args.root:
if args.json:
common.stdout_json({'root_prefix': config.root_dir})
else:
print(config.root_dir)
return
if args.packages:
if args.json:
results = defaultdict(list)
for arg in args.packages:
for pkg in get_package_versions(arg):
results[arg].append(pkg._asdict())
common.stdout_json(results)
return
index = get_index()
r = Resolve(index)
specs = map(common.arg2spec, args.packages)
for spec in specs:
versions = r.get_pkgs(spec)
for pkg in sorted(versions):
pretty_package(pkg)
return
options = 'envs', 'system', 'license'
try:
import requests
requests_version = requests.__version__
except ImportError:
requests_version = "could not import"
except Exception as e:
requests_version = "Error %s" % e
try:
import conda_build
except ImportError:
conda_build_version = "not installed"
except Exception as e:
conda_build_version = "Error %s" % e
else:
conda_build_version = conda_build.__version__
# this is a hack associated with channel weight until we get the package cache reworked
# in a future release
# for now, just ordering the channels for display in a semi-plausible way
d = defaultdict(list)
any(d[v[1]].append(k) for k, v in iteritems(config.get_channel_urls()))
channels = list(chain.from_iterable(d[q] for q in sorted(d, reverse=True)))
info_dict = dict(
platform=config.subdir,
conda_version=conda.__version__,
conda_build_version=conda_build_version,
root_prefix=config.root_dir,
root_writable=config.root_writable,
pkgs_dirs=config.pkgs_dirs,
envs_dirs=config.envs_dirs,
default_prefix=config.default_prefix,
channels=channels,
rc_path=config.rc_path,
user_rc_path=config.user_rc_path,
sys_rc_path=config.sys_rc_path,
is_foreign=bool(config.foreign),
envs=[],
python_version='.'.join(map(str, sys.version_info)),
requests_version=requests_version,
)
if args.unsafe_channels:
if not args.json:
print("\n".join(info_dict["channels"]))
else:
print(json.dumps({"channels": info_dict["channels"]}))
return 0
else:
info_dict['channels'] = [
config.hide_binstar_tokens(c) for c in info_dict['channels']
]
if args.all or args.json:
for option in options:
setattr(args, option, True)
if args.all or all(not getattr(args, opt) for opt in options):
for key in 'pkgs_dirs', 'envs_dirs', 'channels':
info_dict['_' + key] = ('\n' + 24 * ' ').join(info_dict[key])
info_dict['_rtwro'] = ('writable'
if info_dict['root_writable'] else 'read only')
print("""\
Current conda install:
platform : %(platform)s
conda version : %(conda_version)s
conda-build version : %(conda_build_version)s
python version : %(python_version)s
requests version : %(requests_version)s
root environment : %(root_prefix)s (%(_rtwro)s)
default environment : %(default_prefix)s
envs directories : %(_envs_dirs)s
package cache : %(_pkgs_dirs)s
channel URLs : %(_channels)s
config file : %(rc_path)s
is foreign system : %(is_foreign)s
""" % info_dict)
if not is_initialized():
print("""\
# NOTE:
# root directory '%s' is uninitialized""" % config.root_dir)
if args.envs:
common.handle_envs_list(info_dict['envs'], not args.json)
if args.system and not args.json:
from conda.cli.find_commands import find_commands, find_executable
print("sys.version: %s..." % (sys.version[:40]))
print("sys.prefix: %s" % sys.prefix)
print("sys.executable: %s" % sys.executable)
print("conda location: %s" % dirname(conda.__file__))
for cmd in sorted(set(find_commands() + ['build'])):
print("conda-%s: %s" % (cmd, find_executable('conda-' + cmd)))
print("user site dirs: ", end='')
site_dirs = get_user_site()
if site_dirs:
print(site_dirs[0])
else:
print()
for site_dir in site_dirs[1:]:
print(' %s' % site_dir)
print()
evars = [
'PATH', 'PYTHONPATH', 'PYTHONHOME', 'CONDA_DEFAULT_ENV',
'CIO_TEST', 'CONDA_ENVS_PATH'
]
if config.platform == 'linux':
evars.append('LD_LIBRARY_PATH')
elif config.platform == 'osx':
evars.append('DYLD_LIBRARY_PATH')
for ev in sorted(evars):
print("%s: %s" % (ev, os.getenv(ev, '<not set>')))
print()
if args.license and not args.json:
try:
from _license import show_info
show_info()
except ImportError:
print("""\
WARNING: could not import _license.show_info
# try:
# $ conda install -n root _license""")
if args.json:
common.stdout_json(info_dict)
def execute(args, parser):
import re
import sys
from conda.api import get_index
from conda.resolve import MatchSpec, Resolve
if args.regex:
try:
pat = re.compile(args.regex, re.I)
except re.error as e:
sys.exit("Error: %r is not a valid regex pattern (exception: %s)" %
(args.regex, e))
else:
pat = None
prefix = common.get_prefix(args)
if not args.canonical:
import conda.config
import conda.install
linked = conda.install.linked(prefix)
extracted = set()
for pkgs_dir in conda.config.pkgs_dirs:
extracted.update(conda.install.extracted(pkgs_dir))
# XXX: Make this work with more than one platform
platform = args.platform or ''
if platform and platform != config.subdir:
args.unknown = False
common.ensure_override_channels_requires_channel(args, dashc=False)
channel_urls = args.channel or ()
index = get_index(channel_urls=channel_urls, prepend=not
args.override_channels, platform=args.platform,
use_cache=args.use_index_cache,
unknown=args.unknown)
r = Resolve(index)
for name in sorted(r.groups):
disp_name = name
if pat and pat.search(name) is None:
continue
if args.outdated:
vers_inst = [dist.rsplit('-', 2)[1] for dist in linked
if dist.rsplit('-', 2)[0] == name]
if not vers_inst:
continue
assert len(vers_inst) == 1, name
pkgs = sorted(r.get_pkgs(MatchSpec(name)))
if not pkgs:
continue
latest = pkgs[-1]
if latest.version == vers_inst[0]:
continue
for pkg in sorted(r.get_pkgs(MatchSpec(name))):
dist = pkg.fn[:-8]
if args.canonical:
print(dist)
continue
if dist in linked:
inst = '*'
elif dist in extracted:
inst = '.'
else:
inst = ' '
print('%-25s %s %-15s %15s %-15s %s' % (
disp_name, inst,
pkg.version,
r.index[pkg.fn]['build'],
config.canonical_channel_name(pkg.channel),
common.disp_features(r.features(pkg.fn)),
))
disp_name = ''
