-
Notifications
You must be signed in to change notification settings - Fork 0
/
demo.py
78 lines (64 loc) · 2.27 KB
/
demo.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
from resolvelib import Resolver, BaseReporter, AbstractProvider
from packaging import version as v, specifiers as s
from index import get, Requirement
#class Candidate:
# def __init__(self, name, version):
# self.name = name
# self.version = v.parse(version)
#class Requirement:
# def __init__(self, name, spec):
# self.name = name
# self.spec = s.SpecifierSet(spec)
class Reporter(BaseReporter):
def starting(self):
#print("Starting")
pass
def starting_round(self, index):
#print("Starting round")
pass
def ending_round(self, index, state):
#print("Ending round")
pass
def ending(self, state):
#print("Ending")
pass
class Provider(AbstractProvider):
def identify(self, dependency):
return dependency.name
def get_preference(self, resolution, candidates, information):
return len(candidates)
def find_matches(self, requirement):
candidates = []
for c in get(requirement.name, requirement.extras):
version = str(c.version)
if version in requirement.specifier and c.filetype == "wheel":
candidates.append(c)
return candidates
def is_satisfied_by(self, requirement, candidate):
if requirement.name != candidate.name:
return False
return candidate.version in requirement.specifier
def get_dependencies(self, candidate):
return list(candidate.dependencies())
def display_resolution(result):
print("--- Pinned Candidates ---")
for name, candidate in result.mapping.items():
print(f"{name}: {candidate.name} {candidate.version}")
print()
print("--- Dependency Graph ---")
for name in result.graph:
targets = ", ".join(result.graph.iter_children(name))
print(f"{name} -> {targets}")
def main(reqs):
# Things I want to resolve.
requirements = [Requirement(r) for r in reqs]
provider = Provider()
reporter = Reporter()
# Create the (reusable) resolver.
resolver = Resolver(provider, reporter)
# Kick off the resolution process, and get the final result.
result = resolver.resolve(requirements)
display_resolution(result)
if __name__ == "__main__":
import sys
main(sys.argv[1:])