def _recurse_prereqs(path, req_only=False):
rf = RequirementsFinder(os.path.join(path, 'setup.py'))
required = [rf.package] ## must be first
for _, pkg_dir in rf.subpackages_list:
required.append(_recurse_prereqs(os.path.join(path, pkg_dir),
req_only))
if not req_only:
for pkg in rf.prerequisite_list:
required.append(find_package_config(pkg, _fetch_deps,
setup_dir=path))
for pkg in rf.requires_list:
required.append(find_package_config(pkg, _fetch_deps, setup_dir=path))
return required
def _fetch_deps(short_name, helper, version, strict, setup_dir=None):
try:
cfg = helper.configuration()
except Exception:
ver_info = ''
if not version is None:
ver_info = ' v.' + str(version)
print('Error loading ' + short_name + ver_info + ' configuration.\n')
raise
if not version is None:
results = [(short_name, version, strict)]
else:
results = [short_name]
for dep in cfg.dependencies:
results.append(find_package_config(dep, _fetch_deps))
return results
def configure_system(
prerequisite_list,
version,
required_python_version="2.4",
install=None,
quiet=False,
sublevel=None,
out=sys.stdout,
err=sys.stderr,
locally=None,
download=None,
options=dict(),
):
"""
Given a list of required software and optionally a Python version,
verify that python is the proper version and that
other required software is installed.
Install missing prerequisites that have an installer defined.
"""
if locally is None: ## parameter value overrides
if "locally" in options.keys():
locally = options["locally"]
else:
locally = True ## default value
if install is None: ## parameter value overrides
if "install" in options.keys():
install = options["install"]
else:
install = True ## default value
if download is None: ## parameter value overrides
if "download" in options.keys():
download = options["download"]
else:
download = False ## default value
if sublevel is None: ## parameter value overrides
if "sublevel" in options.keys():
opts.set_top_level(options["sublevel"])
environment = dict()
try:
environment = read_cache()
skip = False
for arg in sys.argv:
if arg.startswith("clean"):
skip = True
quiet = True
pyver = simplify_version(platform.python_version())
reqver = simplify_version(required_python_version)
if pyver < reqver:
raise FatalError("Python version >= " + reqver + " is required. " + "You are running version " + pyver)
if not quiet:
out.write("CONFIGURE ")
if len(environment):
out.write("(from cache)")
out.write("\n")
environment["PACKAGE_VERSION"] = version
prerequisite_list.insert(0, "httpsproxy_urllib2")
if (
"windows" in platform.system().lower()
and in_prerequisites("mingw", prerequisite_list)
and in_prerequisites("boost", prerequisite_list)
and not in_prerequisites("msvcrt", prerequisite_list)
):
err.write("WARNING: if you're using the boost-python DLL, " + "also add 'msvcrt' as a prerequisite.\n")
if (
"darwin" in platform.system().lower()
and not in_prerequisites("macports", prerequisite_list)
and not in_prerequisites("homebrew", prerequisite_list)
):
if system_uses_macports():
prerequisite_list.insert(0, "macports")
elif system_uses_homebrew():
prerequisite_list.insert(0, "homebrew")
else:
err.write(
"WARNING: neither MacPorts nor Homebrew "
+ "detected. All required libraries will be "
+ "built locally.\n"
)
for help_name in prerequisite_list:
if len(help_name) > 0:
environment = find_package_config(
help_name, __run_helper__, environment, skip, install, quiet, out, err, locally, download
)
save_cache(environment)
except Exception: # pylint: disable=W0703
logfile = os.path.join(opts.target_build_dir, "config.log")
if not os.path.exists(opts.target_build_dir):
mkdir(opts.target_build_dir)
log = open(logfile, "a")
log.write("** Configuration error. **\n" + traceback.format_exc())
log.close()
err.write(
"Configuration error; see "
+ logfile
+ " for details.\n"
+ "If the build fails, run 'python setup.py dependencies "
+ "--show'\nand install the listed packages by hand.\n"
)
raise
return environment
def configure_package(which, locally=True):
return find_package_config(which, __run_helper__, dict(), skip=False, install=True, quiet=False, locally=locally)
def __run_helper__(
short_name,
helper,
version,
strict,
environment,
skip,
install,
quiet,
out=sys.stdout,
err=sys.stderr,
locally=True,
download=False,
):
configured.append(short_name)
try:
cfg = helper.configuration()
except Exception:
ver_info = ""
if version:
ver_info = " v." + str(version)
err.write("Error loading " + short_name + ver_info + " configuration.\n")
raise
for dep in cfg.dependencies:
dep_name = dep
if not is_string(dep):
dep_name = dep[0]
if dep_name in configured:
continue
environment = find_package_config(
dep, __run_helper__, environment, skip, install, quiet, out, err, locally, download
)
if not environment is None:
save_cache(environment)
environment = read_cache()
if not quiet:
msg = "Checking for " + short_name
if version:
msg += " v." + version
if strict:
msg += " (strict)"
msg += " " * (40 - len(msg))
out.write(msg)
out.flush()
if download:
cfg.download(environment, version, strict)
if skip:
cfg.null()
elif not cfg.is_installed(environment, version, strict):
if install:
if not quiet:
out.write("Installing...\n")
cfg.install(environment, version, strict, locally)
elif not quiet:
out.write("not found.\n")
elif cfg.force:
if install:
if not quiet:
out.write("Forcing install...\n")
cfg.install(environment, version, strict, locally)
elif not quiet:
out.write("found.\n")
elif not quiet:
out.write("found.\n")
env = dict(list(cfg.environment.items()) + list(environment.items()))
if not "PREREQUISITES" in env:
env["PREREQUISITES"] = [short_name]
else:
tmp_env = env["PREREQUISITES"] + [short_name]
env["PREREQUISITES"] = list(set(tmp_env))
save_cache(env) ## intermediate cache
return env
