Source code

Revision control

Copy as Markdown

Other Tools

#!/usr/bin/env python
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at
Setup mozbase packages for development.
Packages may be specified as command line arguments.
If no arguments are given, install all packages.
import os
import subprocess
import sys
from optparse import OptionParser
from subprocess import PIPE
from subprocess import check_call as call
except ImportError:
from subprocess import call
# directory containing this file
here = os.path.dirname(os.path.abspath(__file__))
# all python packages
mozbase_packages = [
i for i in os.listdir(here) if os.path.exists(os.path.join(here, i, ""))
test_packages = ["mock"]
extra_packages = ["sphinx"]
def cycle_check(order, dependencies):
"""ensure no cyclic dependencies"""
order_dict = dict([(j, i) for i, j in enumerate(order)])
for package, deps in dependencies.items():
index = order_dict[package]
for d in deps:
assert index > order_dict[d], "Cyclic dependencies detected"
def info(directory):
"get the package information"
assert os.path.exists(os.path.join(directory, ""))
# setup the egg info
call([sys.executable, "", "egg_info"], cwd=directory, stdout=PIPE)
except subprocess.CalledProcessError:
print("Error running in %s" % directory)
# get the .egg-info directory
egg_info = [entry for entry in os.listdir(directory) if entry.endswith(".egg-info")]
assert len(egg_info) == 1, "Expected one .egg-info directory in %s, got: %s" % (
egg_info = os.path.join(directory, egg_info[0])
assert os.path.isdir(egg_info), "%s is not a directory" % egg_info
# read the package information
pkg_info = os.path.join(egg_info, "PKG-INFO")
info_dict = {}
for line in open(pkg_info).readlines():
if not line or line[0].isspace():
continue # XXX neglects description
assert ":" in line
key, value = [i.strip() for i in line.split(":", 1)]
info_dict[key] = value
return info_dict
def get_dependencies(directory):
"returns the package name and dependencies given a package directory"
# get the package metadata
info_dict = info(directory)
# get the .egg-info directory
egg_info = [
entry for entry in os.listdir(directory) if entry.endswith(".egg-info")
# read the dependencies
requires = os.path.join(directory, egg_info, "requires.txt")
dependencies = []
if os.path.exists(requires):
for line in open(requires):
line = line.strip()
# in requires.txt file, a dependency is a non empty line
# Also lines like [device] are sections to mark optional
# dependencies, we don't want those sections.
if line and not (line.startswith("[") and line.endswith("]")):
# return the information
return info_dict["Name"], dependencies
def dependency_info(dep):
"return dictionary of dependency information from a dependency string"
retval = dict(Name=None, Type=None, Version=None)
for joiner in ("==", "<=", ">="):
if joiner in dep:
retval["Type"] = joiner
name, version = [i.strip() for i in dep.split(joiner, 1)]
retval["Name"] = name
retval["Version"] = version
retval["Name"] = dep.strip()
return retval
def unroll_dependencies(dependencies):
unroll a set of dependencies to a flat list
dependencies = {'packageA': set(['packageB', 'packageC', 'packageF']),
'packageB': set(['packageC', 'packageD', 'packageE', 'packageG']),
'packageC': set(['packageE']),
'packageE': set(['packageF', 'packageG']),
'packageF': set(['packageG']),
'packageX': set(['packageA', 'packageG'])}
order = []
# flatten all
packages = set(dependencies.keys())
for deps in dependencies.values():
while len(order) != len(packages):
for package in packages.difference(order):
if set(dependencies.get(package, set())).issubset(order):
raise AssertionError("Cyclic dependencies detected")
cycle_check(order, dependencies) # sanity check
return order
def main(args=sys.argv[1:]):
# parse command line options
usage = "%prog [options] [package] [package] [...]"
parser = OptionParser(usage=usage, description=__doc__)
help="list dependencies for the packages",
"--list", action="store_true", default=False, help="list what will be installed"
help="installs extra supporting packages as well as core mozbase ones",
options, packages = parser.parse_args(args)
if not packages:
# install all packages
packages = sorted(mozbase_packages)
# ensure specified packages are in the list
assert set(packages).issubset(
), "Packages should be in %s (You gave: %s)" % (mozbase_packages, packages)
if options.list_dependencies:
# list the package dependencies
for package in packages:
print("%s: %s" % get_dependencies(os.path.join(here, package)))
# gather dependencies
# TODO: version conflict checking
deps = {}
alldeps = {}
mapping = {} # mapping from subdir name to package name
# core dependencies
for package in packages:
key, value = get_dependencies(os.path.join(here, package))
deps[key] = [dependency_info(dep)["Name"] for dep in value]
mapping[package] = key
# keep track of all dependencies for non-mozbase packages
for dep in value:
alldeps[dependency_info(dep)["Name"]] = "".join(dep.split())
# indirect dependencies
flag = True
while flag:
flag = False
for value in deps.values():
for dep in value:
if dep in mozbase_packages and dep not in deps:
key, value = get_dependencies(os.path.join(here, dep))
deps[key] = [dep for dep in value]
for dep in value:
alldeps[dep] = "".join(dep.split())
mapping[package] = key
flag = True
if flag:
# get the remaining names for the mapping
for package in mozbase_packages:
if package in mapping:
key, value = get_dependencies(os.path.join(here, package))
mapping[package] = key
# unroll dependencies
unrolled = unroll_dependencies(deps)
# make a reverse mapping: package name -> subdirectory
reverse_mapping = dict([(j, i) for i, j in mapping.items()])
# we only care about dependencies in mozbase
unrolled = [package for package in unrolled if package in reverse_mapping]
if options.list:
# list what will be installed
for package in unrolled:
# set up the packages for development
for package in unrolled:
[sys.executable, "", "develop", "--no-deps"],
cwd=os.path.join(here, reverse_mapping[package]),
# add the directory of sys.executable to path to aid the correct
# `easy_install` getting called
os.environ["PATH"] = "%s%s%s" % (
os.environ.get("PATH", "").strip(os.path.pathsep),
# install non-mozbase dependencies
# these need to be installed separately and the --no-deps flag
# subsequently used due to a bug in setuptools; see
pypi_deps = dict([(i, j) for i, j in alldeps.items() if i not in unrolled])
for package, version in pypi_deps.items():
# easy_install should be available since we rely on setuptools
call(["easy_install", version])
# install packages required for unit testing
for package in test_packages:
call(["easy_install", package])
# install extra non-mozbase packages if desired
if options.extra:
for package in extra_packages:
call(["easy_install", package])
if __name__ == "__main__":