예제 #1
0
파일: helpers.py 프로젝트: hauwenc/dephell
def check(root, resolved=True, missed=None, **deps):
    resolver = Resolver(
        graph=Graph(root),
        mutator=Mutator(),
    )
    with patch(
            target='dephell.controllers.dependency.get_repo',
            return_value=resolver.graph._roots[0].repo,
    ):
        result = resolver.resolve(debug=True, silent=True)

    reqs = Requirement.from_graph(resolver.graph, lock=True)
    reqs = {req.name: req for req in reqs}

    try:
        assert result is resolved
    except AssertionError:
        if result is False:
            print(analyze_conflict(resolver=resolver))
        raise

    assert resolver.graph.applied

    for name in sorted(deps.keys()):
        if name not in reqs:
            raise AssertionError('Dep not in graph: ' + name)
        print(name, reqs[name].version)

    for name, version in deps.items():
        assert reqs[name].version == version, '{}: {} != {}'.format(
            name, reqs[name].version, version)

    if missed:
        for name in missed:
            assert name not in reqs
예제 #2
0
def merge(*roots, merged=True, deps=None):
    graph = Graph()
    for root in roots:
        graph.add(root)
    resolver = Resolver(graph=graph, mutator=Mutator())
    resolved = resolver.resolve(level=1)

    try:
        assert merged == resolved
    except AssertionError:
        if resolved is False:
            print(analyze_conflict(resolver=resolver))
        raise

    if deps:
        for dep in deps:
            assert dep in resolver.graph
        names = set(resolver.graph.names) - set(root.name for root in roots)
        assert names == set(deps)

    return resolver
예제 #3
0
from collections import Counter

from dephell.config import config
from dephell.controllers import analyze_conflict
from dephell.converters import InstalledConverter
from dephell.exceptions import ExtraException

# black has no releases not markerd as pre-release.
config.attach(dict(prereleases=True))

# read deps
resolver = InstalledConverter().load_resolver(None)

# build dependencies tree
try:
    resolved = resolver.resolve()
except ExtraException as e:
    print(str(e), e.extra)
    exit(1)
if not resolved:
    print('cannot resolve')
    print(analyze_conflict(resolver=resolver))
    exit(2)

# get most used dependencies
c = Counter()
for dep in resolver.graph:
    for source in dep.constraint.sources:
        c[source] += 1
print(*c.most_common(20)[1:], sep='\n')