Debian Codegraph @

debian/lib/python/debian_linux/debian.py

raw
1 from __future__ import annotations
2
3 import dataclasses
4 import enum
5 import itertools
6 import os.path
7 import re
8 import shlex
9 import typing
10 from typing import (
11 Iterable,
12 Optional,
13 Self,
14 TypeAlias,
15 )
16
17 from .dataclasses_deb822 import field_deb822
18
19
20 class Changelog(list):
21 _top_rules = r"""
22 ^
23 (?P<source>
24 \w[-+0-9a-z.]+
25 )
26 [ ]
27 \(
28 (?P<version>
29 [^\(\)\ \t]+
30 )
31 \)
32 \s+
33 (?P<distribution>
34 [-+0-9a-zA-Z.]+
35 )
36 \;\s+urgency=
37 (?P<urgency>
38 \w+
39 )
40 (?:,|\n)
41 """
42 _top_re = re.compile(_top_rules, re.X)
43 _bottom_rules = r"""
44 ^
45 [ ]--[ ]
46 (?P<maintainer>
47 \S(?:[ ]?\S)*
48 )
49 [ ]{2}
50 (?P<date>
51 (.*)
52 )
53 \n
54 """
55 _bottom_re = re.compile(_bottom_rules, re.X)
56 _ignore_re = re.compile(r'^(?: |\s*\n)')
57
58 class Entry(object):
59 __slot__ = ('distribution', 'source', 'version', 'urgency',
60 'maintainer', 'date')
61
62 def __init__(self, **kwargs):
63 for key, value in kwargs.items():
64 setattr(self, key, value)
65
66 def __init__(self, dir='', version=None, file=None) -> None:
67 if version is None:
68 version = Version
69 if file:
70 self._parse(version, file)
71 else:
72 with open(os.path.join(dir, "debian/changelog"),
73 encoding="UTF-8") as f:
74 self._parse(version, f)
75
76 def _parse(self, version, f) -> None:
77 top_match = None
78 line_no = 0
79
80 for line in f:
81 line_no += 1
82
83 if self._ignore_re.match(line):
84 pass
85 elif top_match is None:
86 top_match = self._top_re.match(line)
87 if not top_match:
88 raise Exception('invalid top line %d in changelog' %
89 line_no)
90 try:
91 v = version(top_match.group('version'))
92 except Exception:
93 if not len(self):
94 raise
95 v = Version(top_match.group('version'))
96 else:
97 bottom_match = self._bottom_re.match(line)
98 if not bottom_match:
99 raise Exception('invalid bottom line %d in changelog' %
100 line_no)
101
102 self.append(self.Entry(
103 distribution=top_match.group('distribution'),
104 source=top_match.group('source'),
105 version=v,
106 urgency=top_match.group('urgency'),
107 maintainer=bottom_match.group('maintainer'),
108 date=bottom_match.group('date')))
109 top_match = bottom_match = None
110
111
112 class Version(object):
113 revision: str | None
114
115 _epoch_re = re.compile(r'\d+$')
116 _upstream_re = re.compile(r'[0-9][A-Za-z0-9.+\-:~]*$')
117 _revision_re = re.compile(r'[A-Za-z0-9+.~]+$')
118
119 def __init__(self, version) -> None:
120 try:
121 split = version.index(':')
122 except ValueError:
123 epoch, rest = None, version
124 else:
125 epoch, rest = version[0:split], version[split+1:]
126 try:
127 split = rest.rindex('-')
128 except ValueError:
129 upstream, revision = rest, None
130 else:
131 upstream, revision = rest[0:split], rest[split+1:]
132 if (epoch is not None and not self._epoch_re.match(epoch)) or \
133 not self._upstream_re.match(upstream) or \
134 (revision is not None and not self._revision_re.match(revision)):
135 raise RuntimeError(u"Invalid debian version")
136 self.epoch = epoch and int(epoch)
137 self.upstream = upstream
138 self.revision = revision
139
140 def __str__(self) -> str:
141 return self.complete
142
143 @property
144 def complete(self) -> str:
145 if self.epoch is not None:
146 return u"%d:%s" % (self.epoch, self.complete_noepoch)
147 return self.complete_noepoch
148
149 @property
150 def complete_noepoch(self) -> str:
151 if self.revision is not None:
152 return u"%s-%s" % (self.upstream, self.revision)
153 return self.upstream
154
155 @property
156 def debian(self) -> str | None:
157 from warnings import warn
158 warn(u"debian argument was replaced by revision", DeprecationWarning,
159 stacklevel=2)
160 return self.revision
161
162
163 class VersionLinux(Version):
164 _upstream_re = re.compile(r"""
165 (?P<version>
166 \d+\.\d+
167 )
168 (?P<update>
169 (?:\.\d+)?
170 (?:-[a-z]+\d+)?
171 )
172 (?:
173 ~
174 (?P<modifier>
175 .+?
176 )
177 )?
178 $
179 """, re.X)
180
181 def __init__(self, version) -> None:
182 super(VersionLinux, self).__init__(version)
183 up_match = self._upstream_re.match(self.upstream)
184 assert self.revision is not None
185 rev_match = self._revision_re.match(self.revision)
186 if up_match is None or rev_match is None:
187 raise RuntimeError(u"Invalid debian linux version")
188 d = up_match.groupdict()
189 self.linux_version = d['version']
190 self.linux_version_full = self.linux_version + d['update']
191 if d['modifier'] is not None:
192 self.linux_version_full += '-' + d['modifier']
193
194
195 class PackageArchitecture(set[str]):
196 def __init__(
197 self,
198 v: str | Iterable[str] | None = None,
199 /,
200 ) -> None:
201 if v:
202 if isinstance(v, str):
203 v = re.split(r'\s+', v.strip())
204 self |= frozenset(v)
205
206 def __str__(self) -> str:
207 return ' '.join(sorted(self))
208
209
210 class PackageDescription:
211 short: list[str]
212 long: list[str]
213
214 def __init__(
215 self,
216 v: str | Self | None = None,
217 /,
218 ) -> None:
219 self.short = []
220 self.long = []
221
222 if v:
223 if isinstance(v, str):
224 desc_split = v.split('\n', 1)
225 self.append_short(desc_split[0])
226 if len(desc_split) == 2:
227 self.append(desc_split[1])
228 else:
229 self.short.extend(v.short)
230 self.long.extend(v.long)
231
232 def __str__(self) -> str:
233 from .utils import TextWrapper
234 wrap = TextWrapper(width=74, fix_sentence_endings=True).wrap
235 short = ', '.join(self.short)
236 long_pars = []
237 for i in self.long:
238 long_pars.append(wrap(i))
239 long = '\n.\n'.join('\n'.join(i) for i in long_pars)
240 return short + '\n' + long if long else short
241
242 def append(self, long: str) -> None:
243 long = long.strip()
244 if long:
245 self.long.extend(long.split('\n.\n'))
246
247 def append_short(self, short: str) -> None:
248 for i in [i.strip() for i in short.split(',')]:
249 if i:
250 self.short.append(i)
251
252 def extend(self, desc: PackageDescription) -> None:
253 self.short.extend(desc.short)
254 self.long.extend(desc.long)
255
256
257 class PackageRelationEntryOperator(enum.StrEnum):
258 OP_LT = '<<'
259 OP_LE = '<='
260 OP_EQ = '='
261 OP_NE = '!='
262 OP_GE = '>='
263 OP_GT = '>>'
264
265 def __neg__(self) -> PackageRelationEntryOperator:
266 return typing.cast(PackageRelationEntryOperator, {
267 self.OP_LT: self.OP_GE,
268 self.OP_LE: self.OP_GT,
269 self.OP_EQ: self.OP_NE,
270 self.OP_NE: self.OP_EQ,
271 self.OP_GE: self.OP_LT,
272 self.OP_GT: self.OP_LE,
273 }[self])
274
275
276 class PackageRelationEntry:
277 name: str
278 operator: typing.Optional[PackageRelationEntryOperator]
279 version: typing.Optional[str]
280 arches: PackageArchitecture
281 restrictions: PackageBuildprofile
282
283 __re = re.compile(
284 r'^(?P<name>\S+)'
285 r'(?: \((?P<operator><<|<=|=|!=|>=|>>)\s*(?P<version>[^)]+)\))?'
286 r'(?: \[(?P<arches>[^]]+)\])?'
287 r'(?P<restrictions>(?: <[^>]+>)*)$'
288 )
289
290 def __init__(
291 self,
292 v: str | Self,
293 /, *,
294 name: str | None = None,
295 arches: set[str] | None = None,
296 restrictions: PackageBuildprofile | str | None = None,
297 ) -> None:
298 if isinstance(v, str):
299 match = self.__re.match(v)
300 if not match:
301 raise RuntimeError('Unable to parse dependency "%s"' % v)
302
303 self.name = name or match['name']
304
305 if operator := match['operator']:
306 self.operator = PackageRelationEntryOperator(operator)
307 else:
308 self.operator = None
309
310 self.version = match['version']
311 self.arches = PackageArchitecture(arches or match['arches'])
312 if isinstance(restrictions, PackageBuildprofile):
313 self.restrictions = restrictions.copy()
314 else:
315 self.restrictions = PackageBuildprofile.parse(
316 restrictions or match['restrictions'],
317 )
318
319 else:
320 self.name = name or v.name
321 self.operator = v.operator
322 self.version = v.version
323 self.arches = PackageArchitecture(arches or v.arches)
324 if isinstance(restrictions, str):
325 self.restrictions = PackageBuildprofile.parse(restrictions)
326 else:
327 self.restrictions = (restrictions or v.restrictions).copy()
328
329 def __str__(self):
330 ret = [self.name]
331 if self.operator and self.version:
332 ret.append(f'({self.operator} {self.version})')
333 if self.arches:
334 ret.append(f'[{self.arches}]')
335 ret.append(str(self.restrictions))
336 return ' '.join(i for i in ret if i)
337
338
339 class PackageRelationGroup(list[PackageRelationEntry]):
340 def __init__(
341 self,
342 v: Iterable[PackageRelationEntry | str] | str | Self | None = None,
343 /, *,
344 arches: set[str] | None = None,
345 restrictions: PackageBuildprofile | str | None = None,
346 ) -> None:
347 if v:
348 if isinstance(v, str):
349 v = (i.strip() for i in re.split(r'\|', v.strip()))
350 self.extend(PackageRelationEntry(i, arches=arches, restrictions=restrictions)
351 for i in v if i)
352
353 def __str__(self) -> str:
354 return ' | '.join(str(i) for i in self)
355
356 def _merge_eq(self, v: PackageRelationGroup) -> typing.Optional[PackageRelationGroup]:
357 if all(
358 (
359 i.name == j.name and i.operator == j.operator
360 and i.version == j.version
361 ) for i, j in zip(self, v)
362 ):
363 return self
364 return None
365
366
367 class PackageRelation(list[PackageRelationGroup]):
368 Init: TypeAlias = PackageRelationGroup | Iterable[PackageRelationEntry] | str
369
370 def __init__(
371 self,
372 v: Iterable[Init] | str | Self | None = None,
373 /, *,
374 arches: set[str] | None = None,
375 ) -> None:
376 if v:
377 if isinstance(v, str):
378 v = (i.strip() for i in re.split(r',', v.strip()))
379 self.extend(PackageRelationGroup(i, arches=arches) for i in v if i)
380
381 def __str__(self) -> str:
382 return ', '.join(sorted((str(i) for i in self), key=lambda s: s.replace('$', '~')))
383
384 def _merge_eq(self, v: PackageRelationGroup) -> typing.Optional[PackageRelationGroup]:
385 for i in self:
386 if i._merge_eq(v):
387 return i
388 return None
389
390 def merge(
391 self,
392 v: Init | str,
393 /,
394 ) -> None:
395 v = PackageRelationGroup(v)
396 if g := self._merge_eq(v):
397 for i, j in zip(g, v):
398 i.arches |= j.arches
399 i.restrictions.update(j.restrictions)
400 else:
401 super().append(v)
402
403
404 @dataclasses.dataclass
405 class PackageBuildprofileEntry:
406 pos: set[str] = dataclasses.field(default_factory=set)
407 neg: set[str] = dataclasses.field(default_factory=set)
408
409 def copy(self) -> Self:
410 return self.__class__(
411 pos=set(self.pos),
412 neg=set(self.neg),
413 )
414
415 @classmethod
416 def parse(cls, v: str, /) -> Self:
417 ret = cls()
418 for i in re.split(r' ', v):
419 if i:
420 if i[0] == '!':
421 ret.neg.add(i[1:])
422 else:
423 ret.pos.add(i)
424 if ret.pos & ret.neg:
425 raise ValueError
426 return ret
427
428 def __eq__(self, other: object, /) -> bool:
429 if not isinstance(other, PackageBuildprofileEntry):
430 return NotImplemented
431 return self.pos == other.pos and self.neg == other.neg
432
433 def isdisjoint(self, other: Self, /) -> bool:
434 return not (self.issubset(other)) and not (self.issuperset(other))
435
436 def issubset(self, other: Self, /) -> bool:
437 '''
438 Test wether this build profile would select a subset of packages.
439
440 For positive profile matches: Ading profiles will select a subset.
441 For negative profile matches: Removing profiles will select a subset.
442 '''
443 return self.pos >= other.pos and self.neg <= other.neg
444 __le__ = issubset
445
446 def issuperset(self, other: Self, /) -> bool:
447 '''
448 Test wether this build profile would select a superset of packages.
449
450 For positive profile matches: Removing profiles will select a superset.
451 For negative profile matches: Adding profiles will select a superset.
452 '''
453 return self.pos <= other.pos and self.neg >= other.neg
454 __ge__ = issuperset
455
456 def update(self, other: Self, /) -> Self:
457 '''
458 Update the build profiles, adding entries from other, merging if possible.
459
460 Negating entries (profile vs !profile) are completely removed.
461 All others remain if they are used on both sides.
462 '''
463 diff = (self.pos & other.neg) | (self.neg & other.pos)
464 self.pos &= other.pos
465 self.neg &= other.neg
466 self.pos -= diff
467 self.neg -= diff
468 return self
469 __ior__ = update
470
471 def intersection_update(self, other: Self, /) -> Self:
472 '''
473 Update the build profiles, creating an intersection of both.
474
475 Negating entries (profile vs !profile) are completely removed.
476 All others remain.
477 '''
478 diff = (self.pos & other.neg) | (self.neg & other.pos)
479 self.pos |= other.pos
480 self.neg |= other.neg
481 self.pos -= diff
482 self.neg -= diff
483 return self
484 __iand__ = intersection_update
485
486 def __len__(self) -> int:
487 return len(self.pos) + len(self.neg)
488
489 def __str__(self) -> str:
490 return ' '.join(itertools.chain(
491 sorted(self.pos),
492 (f'!{i}' for i in sorted(self.neg)),
493 ))
494
495
496 class PackageBuildprofile(list[PackageBuildprofileEntry]):
497 __re = re.compile(r' *<(?P<entry>[a-z0-9. !-]+)>(?: +|$)')
498
499 def copy(self) -> Self:
500 return self.__class__(i.copy() for i in self)
501
502 @classmethod
503 def parse(cls, v: str, /) -> Self:
504 ret = cls()
505 for match in cls.__re.finditer(v):
506 ret.append(PackageBuildprofileEntry.parse(match.group('entry')))
507 return ret
508
509 def update(self, v: Self, /) -> Self:
510 if len(v) > 1:
511 raise ValueError
512 if not v:
513 self[:] = []
514 elif self:
515 for i in v:
516 for j in self:
517 if not j.isdisjoint(i):
518 j.update(i)
519 break
520 else:
521 self.append(i)
522 return self
523 __ior__ = update
524
525 def intersection_update(self, v: Self, /) -> Self:
526 if len(v) > 1:
527 raise ValueError
528 for i in v:
529 if self:
530 for j in self:
531 j.intersection_update(i)
532 else:
533 self.append(i)
534 return self
535 __iand__ = intersection_update
536
537 def __str__(self) -> str:
538 return ' '.join(f'<{str(i)}>' for i in self if i)
539
540
541 @dataclasses.dataclass
542 class _BasePackage:
543 name: Optional[str]
544 architecture: PackageArchitecture = field_deb822(
545 'Architecture',
546 default_factory=PackageArchitecture,
547 )
548 section: Optional[str] = field_deb822(
549 'Section',
550 default=None,
551 )
552 priority: Optional[str] = field_deb822(
553 'Priority',
554 default=None,
555 )
556
557
558 @dataclasses.dataclass
559 class SourcePackage(_BasePackage):
560 name: Optional[str] = field_deb822(
561 'Source',
562 default=None,
563 )
564 maintainer: Optional[str] = field_deb822(
565 'Maintainer',
566 default=None,
567 )
568 uploaders: Optional[str] = field_deb822(
569 'Uploaders',
570 default=None,
571 )
572 standards_version: Optional[str] = field_deb822(
573 'Standards-Version',
574 default=None,
575 )
576 build_depends: PackageRelation = field_deb822(
577 'Build-Depends',
578 default_factory=PackageRelation,
579 )
580 build_depends_arch: PackageRelation = field_deb822(
581 'Build-Depends-Arch',
582 default_factory=PackageRelation,
583 )
584 build_depends_indep: PackageRelation = field_deb822(
585 'Build-Depends-Indep',
586 default_factory=PackageRelation,
587 )
588 rules_requires_root: Optional[str] = field_deb822(
589 'Rules-Requires-Root',
590 default=None,
591 )
592 homepage: Optional[str] = field_deb822(
593 'Homepage',
594 default=None,
595 )
596 vcs_browser: Optional[str] = field_deb822(
597 'Vcs-Browser',
598 default=None,
599 )
600 vcs_git: Optional[str] = field_deb822(
601 'Vcs-Git',
602 default=None,
603 )
604 autobuild: Optional[str] = field_deb822(
605 'XS-Autobuild',
606 default=None,
607 )
608
609
610 @dataclasses.dataclass
611 class BinaryPackage(_BasePackage):
612 name: str = field_deb822('Package')
613 # Build-Depends* fields aren't allowed for binary packages in
614 # the real control file, but we move them to the source
615 # package
616 build_depends: PackageRelation = field_deb822(
617 'Build-Depends',
618 default_factory=PackageRelation,
619 deb822_dump=None,
620 )
621 package_type: Optional[str] = field_deb822(
622 'Package-Type',
623 default=None,
624 ) # for udeb only
625 build_profiles: PackageBuildprofile = field_deb822(
626 'Build-Profiles',
627 deb822_load=PackageBuildprofile.parse,
628 default_factory=PackageBuildprofile,
629 )
630 built_using: PackageRelation = field_deb822(
631 'Built-Using',
632 default_factory=PackageRelation,
633 )
634 provides: PackageRelation = field_deb822(
635 'Provides',
636 default_factory=PackageRelation,
637 )
638 pre_depends: PackageRelation = field_deb822(
639 'Pre-Depends',
640 default_factory=PackageRelation,
641 )
642 depends: PackageRelation = field_deb822(
643 'Depends',
644 default_factory=PackageRelation,
645 )
646 recommends: PackageRelation = field_deb822(
647 'Recommends',
648 default_factory=PackageRelation,
649 )
650 suggests: PackageRelation = field_deb822(
651 'Suggests',
652 default_factory=PackageRelation,
653 )
654 replaces: PackageRelation = field_deb822(
655 'Replaces',
656 default_factory=PackageRelation,
657 )
658 breaks: PackageRelation = field_deb822(
659 'Breaks',
660 default_factory=PackageRelation,
661 )
662 conflicts: PackageRelation = field_deb822(
663 'Conflicts',
664 default_factory=PackageRelation,
665 )
666 multi_arch: Optional[str] = field_deb822(
667 'Multi-Arch',
668 default=None,
669 )
670 udeb_kernel_version: Optional[str] = field_deb822(
671 'Kernel-Version',
672 default=None,
673 ) # for udeb only
674 description: PackageDescription = field_deb822(
675 'Description',
676 default_factory=PackageDescription,
677 )
678 meta_architectures: PackageArchitecture = dataclasses.field(
679 default_factory=PackageArchitecture,
680 )
681 meta_rules_check_packages: bool = False
682 meta_rules_makeflags: dict = field_deb822(
683 'Meta-Rules-Makeflags',
684 default_factory=dict,
685 deb822_load=lambda v: dict(i.split('=', 1) for i in shlex.split(v)),
686 deb822_dump=None,
687 )
688 meta_rules_ruleids: dict = dataclasses.field(default_factory=dict)
689 meta_rules_target: Optional[str] = field_deb822(
690 'Meta-Rules-Target',
691 default=None,
692 deb822_dump=None,
693 )
694 meta_sign_package: Optional[str] = field_deb822(
695 'Meta-Sign-Package',
696 default=None,
697 deb822_dump=None,
698 )
699 meta_sign_files: list[str] = field_deb822(
700 'Meta-Sign-Files',
701 default_factory=list,
702 deb822_load=lambda v: v.split(),
703 deb822_dump=None,
704 )
705
706
707 @dataclasses.dataclass
708 class TestsControl:
709 tests: Optional[str] = field_deb822(
710 'Tests',
711 default=None,
712 )
713 test_command: Optional[str] = field_deb822(
714 'Test-Command',
715 default=None,
716 )
717 architecture: PackageArchitecture = field_deb822(
718 'Architecture',
719 default_factory=PackageArchitecture,
720 )
721 restrictions: Optional[str] = field_deb822(
722 'Restrictions',
723 default=None,
724 )
725 features: Optional[str] = field_deb822(
726 'Features',
727 default=None,
728 )
729 depends: PackageRelation = field_deb822(
730 'Depends',
731 default_factory=PackageRelation,
732 )
733 tests_directory: Optional[str] = field_deb822(
734 'Tests-Directory',
735 default=None,
736 )
737 classes: Optional[str] = field_deb822(
738 'Classes',
739 default=None,
740 )