Coverage for britney2/installability/universe.py: 96%

1# -*- coding: utf-8 -*- 

2 

3# Copyright (C) 2012 Niels Thykier <niels@thykier.net> 

4 

5# This program is free software; you can redistribute it and/or modify 

6# it under the terms of the GNU General Public License as published by 

7# the Free Software Foundation; either version 2 of the License, or 

8# (at your option) any later version. 

9 

10# This program is distributed in the hope that it will be useful, 

11# but WITHOUT ANY WARRANTY; without even the implied warranty of 

12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

13# GNU General Public License for more details. 

14 

15from typing import TYPE_CHECKING 

16from collections.abc import Iterator 

17 

18if TYPE_CHECKING: 18 ↛ 19line 18 didn't jump to line 19, because the condition on line 18 was never true

19 from .. import BinaryPackageId 

20 

21 

22class BinaryPackageRelation(object): 

23 """All relations of a given binary package""" 

24 

25 __slots__ = [ 

26 "pkg_ids", 

27 "dependencies", 

28 "negative_dependencies", 

29 "reverse_dependencies", 

30 ] 

31 

32 def __init__( 

33 self, 

34 pkg_ids: frozenset["BinaryPackageId"], 

35 dependencies: frozenset[frozenset["BinaryPackageId"]], 

36 negative_dependencies: frozenset["BinaryPackageId"], 

37 reverse_dependencies: set["BinaryPackageId"], 

38 ) -> None: 

39 self.pkg_ids = pkg_ids 

40 self.dependencies = dependencies 

41 self.negative_dependencies = negative_dependencies 

42 self.reverse_dependencies = reverse_dependencies 

43 

44 

45class BinaryPackageUniverse(object): 

46 """A "universe" of all binary packages and their relations 

47 

48 The package universe is a read-only ("immutable") data structure 

49 that knows of all binary packages and their internal relations. 

50 The relations are either in Conjunctive Normal Form (CNF) represented 

51 via sets of sets of the package ids or simply sets of package ids. 

52 

53 Being immutable, the universe does *not* track stateful data such 

54 as "which package is in what suite?" nor "is this package installable 

55 in that suite?". 

56 

57 The universe also includes some packages that are considered "broken". 

58 These packages have been identified to always be uninstallability 

59 regardless of the selection of package available (e.g. the depend 

60 on a non-existent package or has a relation that is impossible to 

61 satisfy). 

62 

63 For these packages, the universe only tracks that they 

64 exist and that they are broken. This implies that their relations 

65 have been nulled into empty sets and they have been removed from 

66 the relations of other packages. This optimizes analysis of the 

67 universe on packages that is/can be installable at the expense 

68 of a "minor" lie about the "broken" packages. 

69 """ 

70 

71 def __init__( 

72 self, 

73 relations: dict["BinaryPackageId", BinaryPackageRelation], 

74 essential_packages: frozenset["BinaryPackageId"], 

75 broken_packages: frozenset["BinaryPackageId"], 

76 equivalent_packages: frozenset["BinaryPackageId"], 

77 ) -> None: 

78 self._relations = relations 

79 self._essential_packages = essential_packages 

80 self._broken_packages = broken_packages 

81 self._equivalent_packages = equivalent_packages 

82 

83 def dependencies_of( 

84 self, pkg_id: "BinaryPackageId" 

85 ) -> frozenset[frozenset["BinaryPackageId"]]: 

86 """Returns the set of dependencies of a given package 

87 

88 :return: A set containing the package ids all of the dependencies 

89 of the input package in CNF. 

90 """ 

91 return self._relations[pkg_id].dependencies 

92 

93 def negative_dependencies_of( 

94 self, pkg_id: "BinaryPackageId" 

95 ) -> frozenset["BinaryPackageId"]: 

96 """Returns the set of negative dependencies of a given package 

97 

98 Note that there is no "reverse_negative_dependencies_of" method, 

99 since negative dependencies have no "direction" unlike positive 

100 dependencies. 

101 

102 :return: A set containing the package ids all of the negative 

103 dependencies of the input package. 

104 """ 

105 return self._relations[pkg_id].negative_dependencies 

106 

107 def reverse_dependencies_of( 

108 self, pkg_id: "BinaryPackageId" 

109 ) -> set["BinaryPackageId"]: 

110 """Returns the set of reverse dependencies of a given package 

111 

112 Note that a package is considered a reverse dependency of the 

113 given package as long as at least one of its dependency relations 

114 *could* be satisfied by the given package. 

115 

116 :return: A set containing the package ids all of the reverse 

117 dependencies of the input package. 

118 """ 

119 return self._relations[pkg_id].reverse_dependencies 

120 

121 def are_equivalent( 

122 self, pkg_id1: "BinaryPackageId", pkg_id2: "BinaryPackageId" 

123 ) -> bool: 

124 """Test if pkg_id1 and pkg_id2 are equivalent 

125 

126 :param pkg_id1: The id of the first package 

127 :param pkg_id2: The id of the second package 

128 :return: True if pkg_id1 and pkg_id2 have the same "signature" in 

129 the package dependency graph (i.e. relations can not tell 

130 them apart semantically except for their name). Otherwise False. 

131 

132 Note that this can return True even if pkg_id1 and pkg_id2 can 

133 tell each other apart. 

134 """ 

135 return pkg_id2 in self.packages_equivalent_to(pkg_id1) 

136 

137 def packages_equivalent_to( 

138 self, pkg_id: "BinaryPackageId" 

139 ) -> frozenset["BinaryPackageId"]: 

140 """Determine which packages are equivalent to a given package 

141 

142 :return: A frozenset of all package ids that are equivalent to the 

143 input package. 

144 """ 

145 return self._relations[pkg_id].pkg_ids 

146 

147 def relations_of(self, pkg_id: "BinaryPackageId") -> BinaryPackageRelation: 

148 """Get the direct relations of a given package 

149 

150 :param pkg_id: The BinaryPackageId of a binary package. 

151 :return: A BinaryPackageRelation describing all known direct 

152 relations for the package. 

153 """ 

154 return self._relations[pkg_id] 

155 

156 @property 

157 def essential_packages(self) -> frozenset["BinaryPackageId"]: 

158 """A frozenset of all "Essential: yes" binaries in the universe 

159 

160 :return: All of the binaries that are marked as essential. 

161 """ 

162 return self._essential_packages 

163 

164 @property 

165 def broken_packages(self) -> frozenset["BinaryPackageId"]: 

166 """A frozenset of all broken binaries in the universe 

167 

168 :return: All binaries that are considered "broken" and had their relations nulled. 

169 """ 

170 return self._broken_packages 

171 

172 @property 

173 def equivalent_packages(self) -> frozenset["BinaryPackageId"]: 

174 """A frozenset of all binary packages that are equivalent to at least one other package 

175 

176 The binary packages in this set has the property that "universe.packages_equivalent_to(pkg_id)" 

177 will return a set of at least 2 or more elements for each of them. 

178 

179 :return: All packages that are equivalent to other packages. 

180 """ 

181 return self._equivalent_packages 

182 

183 def __contains__(self, pkg_id: "BinaryPackageId") -> bool: 

184 return pkg_id in self._relations 

185 

186 def __iter__(self) -> Iterator["BinaryPackageId"]: 

187 yield from self._relations