Adding debian version 6.10.3-1.debian/6.10.3-1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

7 files changed, 546 insertions, 249 deletions

diff --git a/debian/lib/python/debian_linux/config_v2.py b/debian/lib/python/debian_linux/config_v2.py
index 1c32bc8864..744c3276c2 100644
--- a/debian/lib/python/debian_linux/config_v2.py
+++ b/debian/lib/python/debian_linux/config_v2.py
@@ -304,6 +304,22 @@ class ConfigFeatureset(ConfigBase):
                 for flavour in debianarch.flavour
             ]
 
+        if self.flavour:
+            # XXX: Remove special case of name
+            if self.name == 'none':
+                flavour_default = [i for i in self.flavour if i.defs.is_default]
+                flavour_quick = [i for i in self.flavour if i.defs.is_quick]
+
+                if not flavour_quick:
+                    flavour_quick = flavour_default or self.flavour[0:1]
+                    flavour_quick[0].defs.is_quick = True
+
+            # Flavours in other featuresets can never be default or quick
+            else:
+                for flavour in self.flavour:
+                    flavour.defs.is_default = False
+                    flavour.defs.is_quick = False
+
         self.__post_init_hierarchy__(path)
 
 
diff --git a/debian/lib/python/debian_linux/dataclasses_deb822.py b/debian/lib/python/debian_linux/dataclasses_deb822.py
new file mode 100644
index 0000000000..9858296ec4
--- /dev/null
+++ b/debian/lib/python/debian_linux/dataclasses_deb822.py
@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import dataclasses
+import re
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    IO,
+    Iterable,
+    Optional,
+    overload,
+    TypeVar,
+    TYPE_CHECKING,
+)
+
+_T = TypeVar('_T')
+
+if TYPE_CHECKING:
+    from dataclasses import _DataclassT
+else:
+    # We can only get to _DataclassT during type checking, use a generic type during runtime
+    _DataclassT = _T
+
+__all__ = [
+    'field_deb822',
+    'read_deb822',
+    'write_deb822',
+    'Deb822DecodeError',
+]
+
+
+class Deb822Field(Generic[_T]):
+    key: str
+    load: Optional[Callable[[str], _T]]
+    dump: Optional[Callable[[_T], str]]
+
+    def __init__(
+        self, *,
+        key: str,
+        load: Optional[Callable[[str], _T]],
+        dump: Optional[Callable[[_T], str]],
+    ) -> None:
+        self.key = key
+        self.load = load
+        self.dump = dump
+
+
+# The return type _T is technically wrong, but it allows checking if during
+# runtime we get the correct type.
+@overload
+def field_deb822(
+    deb822_key: str,
+    /, *,
+    deb822_load: Optional[Callable[[str], _T]] = None,
+    deb822_dump: Optional[Callable[[_T], str]] = str,
+    default: _T,
+) -> _T:
+    ...
+
+
+@overload
+def field_deb822(
+    deb822_key: str,
+    /, *,
+    deb822_load: Optional[Callable[[str], _T]] = None,
+    deb822_dump: Optional[Callable[[_T], str]] = str,
+    default_factory: Callable[[], _T],
+) -> _T:
+    ...
+
+
+@overload
+def field_deb822(
+    deb822_key: str,
+    /, *,
+    deb822_load: Optional[Callable[[str], _T]] = None,
+    deb822_dump: Optional[Callable[[_T], str]] = str,
+) -> _T:
+    ...
+
+
+def field_deb822(
+    deb822_key: str,
+    /, *,
+    deb822_load: Optional[Callable[[str], _T]] = None,
+    deb822_dump: Optional[Callable[[_T], str]] = str,
+    default: Any = dataclasses.MISSING,
+    default_factory: Any = dataclasses.MISSING,
+) -> Any:
+    metadata: dict[str, Any] = {
+        'deb822': Deb822Field(
+            key=deb822_key,
+            load=deb822_load,
+            dump=deb822_dump,
+        ),
+    }
+
+    if default is not dataclasses.MISSING:
+        return dataclasses.field(
+            default=default,
+            metadata=metadata,
+        )
+    else:
+        return dataclasses.field(
+            default_factory=default_factory,
+            metadata=metadata,
+        )
+
+
+class Deb822DecodeError(ValueError):
+    pass
+
+
+class Deb822DecodeState(Generic[_DataclassT]):
+    cls: type[_DataclassT]
+    fields: dict[str, dataclasses.Field]
+    ignore_unknown: bool
+
+    data: dict[Optional[dataclasses.Field], str]
+    current: Optional[dataclasses.Field]
+
+    _line_re = re.compile(r'''
+        ^
+        (
+            [ \t](?P<cont>.*)
+            |
+            (?P<key>[^: \t\n\r\f\v]+)\s*:\s*(?P<value>.*)
+        )
+        $
+    ''', re.VERBOSE)
+
+    def __init__(
+        self,
+        cls: type[_DataclassT],
+        ignore_unknown: bool,
+    ) -> None:
+        self.reset()
+
+        self.cls = cls
+        self.fields = {}
+        self.ignore_unknown = ignore_unknown
+
+        for i in dataclasses.fields(cls):
+            if i.init and (deb822_field := i.metadata.get('deb822')):
+                self.fields[deb822_field.key] = i
+
+    def reset(self) -> None:
+        self.data = {}
+        self.current = None
+
+    def line(self, linenr: int, line: str) -> None:
+        m = self._line_re.match(line)
+        if not m:
+            raise Deb822DecodeError(
+                f'Not a header, not a continuation at line {linenr + 1}')
+        elif cont := m.group('cont'):
+            self.data[self.current] += '\n' + cont
+        elif deb822_key := m.group('key'):
+            field = self.fields.get(deb822_key)
+            if not field and not self.ignore_unknown:
+                raise Deb822DecodeError(
+                    f'Unknown field "{deb822_key}" at line {linenr + 1}')
+
+            self.current = field
+            self.data[field] = m.group('value')
+        else:
+            raise NotImplementedError
+
+    def generate(self) -> _DataclassT | None:
+        if not self.data:
+            return None
+
+        r: dict[str, Any] = {}
+        for field, value in self.data.items():
+            field_factory: Optional[Callable[[str], Any]] = None
+            if field is None:
+                continue
+            elif (deb822_field := field.metadata.get('deb822')) and (load := deb822_field.load):
+                field_factory = load
+            elif isinstance(field.default_factory, type):
+                field_factory = field.default_factory
+            elif field.type in ('str', 'Optional[str]'):
+                field_factory = str
+            else:
+                raise RuntimeError(f'Unable to parse type {field.type}')
+
+            if field_factory is not None:
+                r[field.name] = field_factory(value)
+
+        self.reset()
+        return self.cls(**r)
+
+
+def read_deb822(
+    cls: type[_DataclassT],
+    file: IO[str],
+    /,
+    ignore_unknown: bool = False,
+) -> Iterable[_DataclassT]:
+    state = Deb822DecodeState(cls, ignore_unknown)
+
+    for linenr, line in enumerate(file):
+        line = line.rstrip('\n')
+
+        # Empty line, end of record
+        if line == '':
+            if (obj := state.generate()):
+                yield obj
+        # Strip comments rather than trying to preserve them
+        elif line[0] == '#':
+            continue
+        else:
+            state.line(linenr, line)
+
+    if (obj := state.generate()):
+        yield obj
+
+
+def write_deb822(
+    objs: Iterable[_DataclassT],
+    file: IO[str],
+    /,
+) -> None:
+    for obj in objs:
+        for field in dataclasses.fields(obj):
+            if (
+                (value := getattr(obj, field.name, None))
+                and (deb822_field := field.metadata.get('deb822'))
+                and (dump := deb822_field.dump) is not None
+            ):
+                folded = '\n '.join(dump(value).strip().split('\n'))
+                file.write(f'{deb822_field.key}: {folded}\n')
+        file.write('\n')
diff --git a/debian/lib/python/debian_linux/debian.py b/debian/lib/python/debian_linux/debian.py
index 4a37b62a66..fc90ccac31 100644
--- a/debian/lib/python/debian_linux/debian.py
+++ b/debian/lib/python/debian_linux/debian.py
@@ -1,20 +1,21 @@
 from __future__ import annotations
 
-import collections
-import collections.abc
 import dataclasses
 import enum
 import itertools
 import os.path
 import re
+import shlex
 import typing
-import warnings
 from typing import (
     Iterable,
+    Optional,
     Self,
     TypeAlias,
 )
 
+from .dataclasses_deb822 import field_deb822
+
 
 class Changelog(list):
     _top_rules = r"""
@@ -273,8 +274,8 @@ class PackageDescription:
         long_pars = []
         for i in self.long:
             long_pars.append(wrap(i))
-        long = '\n .\n '.join('\n '.join(i) for i in long_pars)
-        return short + '\n ' + long if long else short
+        long = '\n.\n'.join('\n'.join(i) for i in long_pars)
+        return short + '\n' + long if long else short
 
     def append(self, long: str) -> None:
         long = long.strip()
@@ -540,166 +541,203 @@ class PackageBuildprofile(list[PackageBuildprofileEntry]):
         return ' '.join(str(i) for i in self)
 
 
-class _ControlFileDict(collections.abc.MutableMapping):
-    def __init__(self):
-        self.__data = {}
-        self.meta = {}
+@dataclasses.dataclass
+class _BasePackage:
+    name: Optional[str]
+    architecture: PackageArchitecture = field_deb822(
+        'Architecture',
+        default_factory=PackageArchitecture,
+    )
+    section: Optional[str] = field_deb822(
+        'Section',
+        default=None,
+    )
+    priority: Optional[str] = field_deb822(
+        'Priority',
+        default=None,
+    )
 
-    def __getitem__(self, key):
-        return self.__data[key]
 
-    def __setitem__(self, key, value):
-        if key.lower().startswith('meta-'):
-            self.meta[key.lower()[5:]] = value
-            return
+@dataclasses.dataclass
+class SourcePackage(_BasePackage):
+    name: Optional[str] = field_deb822(
+        'Source',
+        default=None,
+    )
+    maintainer: Optional[str] = field_deb822(
+        'Maintainer',
+        default=None,
+    )
+    uploaders: Optional[str] = field_deb822(
+        'Uploaders',
+        default=None,
+    )
+    standards_version: Optional[str] = field_deb822(
+        'Standards-Version',
+        default=None,
+    )
+    build_depends: PackageRelation = field_deb822(
+        'Build-Depends',
+        default_factory=PackageRelation,
+    )
+    build_depends_arch: PackageRelation = field_deb822(
+        'Build-Depends-Arch',
+        default_factory=PackageRelation,
+    )
+    build_depends_indep: PackageRelation = field_deb822(
+        'Build-Depends-Indep',
+        default_factory=PackageRelation,
+    )
+    rules_requires_root: Optional[str] = field_deb822(
+        'Rules-Requires-Root',
+        default=None,
+    )
+    homepage: Optional[str] = field_deb822(
+        'Homepage',
+        default=None,
+    )
+    vcs_browser: Optional[str] = field_deb822(
+        'Vcs-Browser',
+        default=None,
+    )
+    vcs_git: Optional[str] = field_deb822(
+        'Vcs-Git',
+        default=None,
+    )
+    autobuild: Optional[str] = field_deb822(
+        'XS-Autobuild',
+        default=None,
+    )
 
-        try:
-            cls = self._fields[key]
-            if not isinstance(value, cls):
-                if f := getattr(cls, 'parse', None):
-                    value = f(value)
-                else:
-                    value = cls(value)
-        except KeyError:
-            warnings.warn(
-                f'setting unknown field {key} in {type(self).__name__}',
-                stacklevel=2)
-        self.__data[key] = value
-
-    def __delitem__(self, key):
-        del self.__data[key]
-
-    def __iter__(self):
-        keys = set(self.__data.keys())
-        for key in self._fields.keys():
-            if key in self.__data:
-                keys.remove(key)
-                yield key
-        for key in sorted(keys):
-            yield key
-
-    def __len__(self):
-        return len(self.__data)
-
-    def setdefault(self, key):
-        try:
-            return self[key]
-        except KeyError:
-            try:
-                ret = self[key] = self._fields[key]()
-            except KeyError:
-                warnings.warn(
-                    f'setting unknown field {key} in {type(self).__name__}',
-                    stacklevel=2)
-                ret = self[key] = ''
-            return ret
-
-    def copy(self):
-        ret = self.__class__()
-        ret.__data = self.__data.copy()
-        ret.meta = self.meta.copy()
-        return ret
 
-    @classmethod
-    def read_rfc822(cls, f):
-        entries = []
-        eof = False
-
-        while not eof:
-            e = cls()
-            last = None
-            lines = []
-            while True:
-                line = f.readline()
-                if not line:
-                    eof = True
-                    break
-                # Strip comments rather than trying to preserve them
-                if line[0] == '#':
-                    continue
-                line = line.strip('\n')
-                if not line:
-                    break
-                if line[0] in ' \t':
-                    if not last:
-                        raise ValueError(
-                            'Continuation line seen before first header')
-                    lines.append(line.lstrip())
-                    continue
-                if last:
-                    e[last] = '\n'.join(lines)
-                i = line.find(':')
-                if i < 0:
-                    raise ValueError(u"Not a header, not a continuation: ``%s''" %
-                                     line)
-                last = line[:i]
-                lines = [line[i + 1:].lstrip()]
-            if last:
-                e[last] = '\n'.join(lines)
-            if e:
-                entries.append(e)
-
-        return entries
-
-
-class SourcePackage(_ControlFileDict):
-    _fields = collections.OrderedDict((
-        ('Source', str),
-        ('Architecture', PackageArchitecture),
-        ('Section', str),
-        ('Priority', str),
-        ('Maintainer', str),
-        ('Uploaders', str),
-        ('Standards-Version', str),
-        ('Build-Depends', PackageRelation),
-        ('Build-Depends-Arch', PackageRelation),
-        ('Build-Depends-Indep', PackageRelation),
-        ('Rules-Requires-Root', str),
-        ('Homepage', str),
-        ('Vcs-Browser', str),
-        ('Vcs-Git', str),
-        ('XS-Autobuild', str),
-    ))
-
-
-class BinaryPackage(_ControlFileDict):
-    _fields = collections.OrderedDict((
-        ('Package', str),
-        ('Package-Type', str),  # for udeb only
-        ('Architecture', PackageArchitecture),
-        ('Section', str),
-        ('Priority', str),
-        # Build-Depends* fields aren't allowed for binary packages in
-        # the real control file, but we move them to the source
-        # package
-        ('Build-Depends', PackageRelation),
-        ('Build-Depends-Arch', PackageRelation),
-        ('Build-Depends-Indep', PackageRelation),
-        ('Build-Profiles', PackageBuildprofile),
-        ('Built-Using', PackageRelation),
-        ('Provides', PackageRelation),
-        ('Pre-Depends', PackageRelation),
-        ('Depends', PackageRelation),
-        ('Recommends', PackageRelation),
-        ('Suggests', PackageRelation),
-        ('Replaces', PackageRelation),
-        ('Breaks', PackageRelation),
-        ('Conflicts', PackageRelation),
-        ('Multi-Arch', str),
-        ('Kernel-Version', str),  # for udeb only
-        ('Description', PackageDescription),
-        ('Homepage', str),
-    ))
-
-
-class TestsControl(_ControlFileDict):
-    _fields = collections.OrderedDict((
-        ('Tests', str),
-        ('Test-Command', str),
-        ('Architecture', PackageArchitecture),
-        ('Restrictions', str),
-        ('Features', str),
-        ('Depends', PackageRelation),
-        ('Tests-Directory', str),
-        ('Classes', str),
-    ))
+@dataclasses.dataclass
+class BinaryPackage(_BasePackage):
+    name: str = field_deb822('Package')
+    # Build-Depends* fields aren't allowed for binary packages in
+    # the real control file, but we move them to the source
+    # package
+    build_depends: PackageRelation = field_deb822(
+        'Build-Depends',
+        default_factory=PackageRelation,
+        deb822_dump=None,
+    )
+    package_type: Optional[str] = field_deb822(
+        'Package-Type',
+        default=None,
+    )  # for udeb only
+    build_profiles: PackageBuildprofile = field_deb822(
+        'Build-Profiles',
+        deb822_load=PackageBuildprofile.parse,
+        default_factory=PackageBuildprofile,
+    )
+    built_using: PackageRelation = field_deb822(
+        'Built-Using',
+        default_factory=PackageRelation,
+    )
+    provides: PackageRelation = field_deb822(
+        'Provides',
+        default_factory=PackageRelation,
+    )
+    pre_depends: PackageRelation = field_deb822(
+        'Pre-Depends',
+        default_factory=PackageRelation,
+    )
+    depends: PackageRelation = field_deb822(
+        'Depends',
+        default_factory=PackageRelation,
+    )
+    recommends: PackageRelation = field_deb822(
+        'Recommends',
+        default_factory=PackageRelation,
+    )
+    suggests: PackageRelation = field_deb822(
+        'Suggests',
+        default_factory=PackageRelation,
+    )
+    replaces: PackageRelation = field_deb822(
+        'Replaces',
+        default_factory=PackageRelation,
+    )
+    breaks: PackageRelation = field_deb822(
+        'Breaks',
+        default_factory=PackageRelation,
+    )
+    conflicts: PackageRelation = field_deb822(
+        'Conflicts',
+        default_factory=PackageRelation,
+    )
+    multi_arch: Optional[str] = field_deb822(
+        'Multi-Arch',
+        default=None,
+    )
+    udeb_kernel_version: Optional[str] = field_deb822(
+        'Kernel-Version',
+        default=None,
+    )  # for udeb only
+    description: PackageDescription = field_deb822(
+        'Description',
+        default_factory=PackageDescription,
+    )
+    meta_architectures: PackageArchitecture = dataclasses.field(
+        default_factory=PackageArchitecture,
+    )
+    meta_rules_check_packages: bool = False
+    meta_rules_makeflags: dict = field_deb822(
+        'Meta-Rules-Makeflags',
+        default_factory=dict,
+        deb822_load=lambda v: dict(i.split('=', 1) for i in shlex.split(v)),
+        deb822_dump=None,
+    )
+    meta_rules_ruleids: dict = dataclasses.field(default_factory=dict)
+    meta_rules_target: Optional[str] = field_deb822(
+        'Meta-Rules-Target',
+        default=None,
+        deb822_dump=None,
+    )
+    meta_sign_package: Optional[str] = field_deb822(
+        'Meta-Sign-Package',
+        default=None,
+        deb822_dump=None,
+    )
+    meta_sign_files: list[str] = field_deb822(
+        'Meta-Sign-Files',
+        default_factory=list,
+        deb822_load=lambda v: v.split(),
+        deb822_dump=None,
+    )
+
+
+@dataclasses.dataclass
+class TestsControl:
+    tests: Optional[str] = field_deb822(
+        'Tests',
+        default=None,
+    )
+    test_command: Optional[str] = field_deb822(
+        'Test-Command',
+        default=None,
+    )
+    architecture: PackageArchitecture = field_deb822(
+        'Architecture',
+        default_factory=PackageArchitecture,
+    )
+    restrictions: Optional[str] = field_deb822(
+        'Restrictions',
+        default=None,
+    )
+    features: Optional[str] = field_deb822(
+        'Features',
+        default=None,
+    )
+    depends: PackageRelation = field_deb822(
+        'Depends',
+        default_factory=PackageRelation,
+    )
+    tests_directory: Optional[str] = field_deb822(
+        'Tests-Directory',
+        default=None,
+    )
+    classes: Optional[str] = field_deb822(
+        'Classes',
+        default=None,
+    )
diff --git a/debian/lib/python/debian_linux/firmware.py b/debian/lib/python/debian_linux/firmware.py
index b1a4a7e85d..4395847815 100644
--- a/debian/lib/python/debian_linux/firmware.py
+++ b/debian/lib/python/debian_linux/firmware.py
@@ -9,7 +9,7 @@ class FirmwareFile(object):
         self.version = version
 
 
-class FirmwareSection(object):
+class FirmwareGroup(object):
     def __init__(self, driver, files, licence) -> None:
         self.driver = driver
         self.files = files
@@ -20,6 +20,12 @@ class FirmwareWhence(list):
     def __init__(self, file) -> None:
         self.read(file)
 
+    @staticmethod
+    def _unquote(name):
+        if len(name) >= 3 and name[0] == '"' and name[-1] == '"':
+            name = name[1:-1]
+        return name
+
     def read(self, file) -> None:
         in_header = True
         driver = None
@@ -35,9 +41,9 @@ class FirmwareWhence(list):
                 if in_header:
                     in_header = False
                 else:
-                    # Finish old section
-                    if driver:
-                        self.append(FirmwareSection(driver, files, licence))
+                    # Finish old group
+                    if driver and files:
+                        self.append(FirmwareGroup(driver, files, licence))
                     driver = None
                     files = {}
                     licence = None
@@ -61,21 +67,27 @@ class FirmwareWhence(list):
                 continue
 
             match = re.match(
-                r'(Driver|File|Info|Licen[cs]e|Source|Version'
+                r'(Driver|(?:Raw)?File|Info|Licen[cs]e|Source|Version'
                 r'|Original licen[cs]e info(?:rmation)?):\s*(.*)\n',
                 line)
             if match:
+                # If we've seen a license for the previous group,
+                # start a new group
+                if licence:
+                    self.append(FirmwareGroup(driver, files, licence))
+                    files = {}
+                    licence = None
                 keyword, value = match.group(1, 2)
                 if keyword == 'Driver':
                     driver = value.split(' ')[0].lower()
-                elif keyword == 'File':
-                    match = re.match(r'(\S+)(?:\s+--\s+(.*))?', value)
-                    binary.append(match.group(1))
+                elif keyword in ['File', 'RawFile']:
+                    match = re.match(r'("[^"\n]+"|\S+)(?:\s+--\s+(.*))?', value)
+                    binary.append(self._unquote(match.group(1)))
                     desc = match.group(2)
                 elif keyword in ['Info', 'Version']:
                     version = value
                 elif keyword == 'Source':
-                    source.append(value)
+                    source.append(self._unquote(value))
                 else:
                     licence = value
             elif licence is not None:
@@ -83,8 +95,8 @@ class FirmwareWhence(list):
                            + re.sub(r'^(?:[/ ]\*| \*/)?\s*(.*?)\s*$', r'\1',
                                     line))
 
-        # Finish last section if non-empty
+        # Finish last group if non-empty
         for b in binary:
             files[b] = FirmwareFile(b, desc, source, version)
         if driver:
-            self.append(FirmwareSection(driver, files, licence))
+            self.append(FirmwareGroup(driver, files, licence))
diff --git a/debian/lib/python/debian_linux/gencontrol.py b/debian/lib/python/debian_linux/gencontrol.py
index 49f52e878b..c3305112c0 100644
--- a/debian/lib/python/debian_linux/gencontrol.py
+++ b/debian/lib/python/debian_linux/gencontrol.py
@@ -4,7 +4,6 @@ import contextlib
 import itertools
 import pathlib
 import re
-from collections import OrderedDict
 from collections.abc import (
     Generator,
 )
@@ -21,23 +20,12 @@ from .config_v2 import (
     ConfigMergedFeatureset,
     ConfigMergedFlavour,
 )
+from .dataclasses_deb822 import write_deb822
 from .debian import Changelog, PackageArchitecture, \
-    Version, _ControlFileDict
+    Version, SourcePackage, BinaryPackage
 from .utils import Templates
 
 
-class PackagesList(OrderedDict):
-    def append(self, package) -> None:
-        self[package['Package']] = package
-
-    def extend(self, packages) -> None:
-        for package in packages:
-            self[package['Package']] = package
-
-    def setdefault(self, package) -> Any:
-        return super().setdefault(package['Package'], package)
-
-
 class Makefile:
     rules: dict[str, MakefileRule]
 
@@ -149,23 +137,35 @@ class MakeFlags(dict):
 
 
 class PackagesBundle:
+    class BinaryPackages(dict[str, BinaryPackage]):
+        def add(self, package: BinaryPackage) -> BinaryPackage:
+            return super().setdefault(package.name, package)
+
     name: str | None
     templates: Templates
     base: pathlib.Path
     makefile: Makefile
-    packages: PackagesList
+    source: SourcePackage
+    packages: BinaryPackages
 
     def __init__(
             self,
             name: str | None,
+            source_template: str,
+            replace: dict[str, str],
             templates: Templates,
             base: pathlib.Path = pathlib.Path('debian'),
+            override_name: str | None = None,
     ) -> None:
         self.name = name
         self.templates = templates
         self.base = base
         self.makefile = Makefile()
-        self.packages = PackagesList()
+        self.source = list(self.templates.get_source_control(source_template, replace))[0]
+        self.packages = self.BinaryPackages()
+
+        if not self.source.name:
+            self.source.name = override_name
 
     def add(
             self,
@@ -179,14 +179,14 @@ class PackagesBundle:
     ) -> list[Any]:
         ret = []
         for raw_package in self.templates.get_control(f'{pkgid}.control', replace):
-            package = self.packages.setdefault(raw_package)
-            package_name = package['Package']
+            package = self.packages.add(raw_package)
+            package_name = package.name
             ret.append(package)
 
-            package.meta.setdefault('rules-ruleids', {})[ruleid] = makeflags
+            package.meta_rules_ruleids[ruleid] = makeflags
             if arch:
-                package.meta.setdefault('architectures', PackageArchitecture()).add(arch)
-            package.meta['rules-check-packages'] = check_packages
+                package.meta_architectures.add(arch)
+            package.meta_rules_check_packages = check_packages
 
             for name in (
                     'NEWS',
@@ -211,7 +211,7 @@ class PackagesBundle:
 
     def add_packages(
             self,
-            packages: Iterable[_ControlFileDict],
+            packages: Iterable[BinaryPackage],
             ruleid: Iterable[str],
             makeflags: MakeFlags,
             *,
@@ -219,11 +219,11 @@ class PackagesBundle:
             check_packages: bool = True,
     ) -> None:
         for package in packages:
-            package = self.packages.setdefault(package)
-            package.meta.setdefault('rules-ruleids', {})[ruleid] = makeflags
+            package = self.packages.add(package)
+            package.meta_rules_ruleids[ruleid] = makeflags
             if arch:
-                package.meta.setdefault('architectures', PackageArchitecture()).add(arch)
-            package.meta['rules-check-packages'] = check_packages
+                package.meta_architectures.add(arch)
+            package.meta_rules_check_packages = check_packages
 
     def path(self, name) -> pathlib.Path:
         if self.name:
@@ -262,20 +262,19 @@ class PackagesBundle:
         targets: dict[frozenset[str], dict] = {}
 
         for package_name, package in self.packages.items():
-            target_name = package.meta.get('rules-target')
-            ruleids = package.meta.get('rules-ruleids')
-            makeflags = MakeFlags({
-                # Requires Python 3.9+
-                k.removeprefix('rules-makeflags-').upper(): v
-                for (k, v) in package.meta.items() if k.startswith('rules-makeflags-')
-            })
+            if not isinstance(package, BinaryPackage):
+                continue
+
+            target_name = package.meta_rules_target
+            ruleids = package.meta_rules_ruleids
+            makeflags = MakeFlags(package.meta_rules_makeflags)
 
             if ruleids:
-                arches = package.meta.get('architectures')
+                arches = package.meta_architectures
                 if arches:
-                    package['Architecture'] = arches
+                    package.architecture = arches
                 else:
-                    arches = package.get('Architecture')
+                    arches = package.architecture
 
                 if target_name:
                     for ruleid, makeflags_package in ruleids.items():
@@ -291,7 +290,7 @@ class PackagesBundle:
                             },
                         )
 
-                        if package.meta['rules-check-packages']:
+                        if package.meta_rules_check_packages:
                             target.setdefault('packages', set()).add(package_name)
                         else:
                             target.setdefault('packages_extra', set()).add(package_name)
@@ -331,46 +330,40 @@ class PackagesBundle:
     def merge_build_depends(self) -> None:
         # Merge Build-Depends pseudo-fields from binary packages into the
         # source package
-        source = self.packages["source"]
         arch_all = PackageArchitecture("all")
         for name, package in self.packages.items():
-            if name == "source":
-                continue
-            dep = package.get("Build-Depends")
+            dep = package.build_depends
             if not dep:
                 continue
-            del package["Build-Depends"]
-            if package["Architecture"] == arch_all:
-                dep_type = "Build-Depends-Indep"
+            if package.architecture == arch_all:
+                build_dep = self.source.build_depends_indep
             else:
-                dep_type = "Build-Depends-Arch"
+                build_dep = self.source.build_depends_arch
             for group in dep:
                 for item in group:
-                    if package["Architecture"] != arch_all and not item.arches:
-                        item.arches = package["Architecture"]
-                    if package.get("Build-Profiles") and not item.restrictions:
-                        item.restrictions = package["Build-Profiles"]
-                source.setdefault(dep_type).merge(group)
+                    if package.architecture != arch_all and not item.arches:
+                        item.arches = package.architecture
+                    if package.build_profiles and not item.restrictions:
+                        item.restrictions = package.build_profiles
+                build_dep.merge(group)
 
     def write(self) -> None:
         self.write_control()
         self.write_makefile()
 
     def write_control(self) -> None:
+        p = [self.source] + sorted(
+            self.packages.values(),
+            # Sort deb before udeb and then according to name
+            key=lambda i: (i.package_type or '', i.name),
+        )
         with self.open('control') as f:
-            self.write_rfc822(f, self.packages.values())
+            write_deb822(p, f)
 
     def write_makefile(self) -> None:
         with self.open('rules.gen') as f:
             self.makefile.write(f)
 
-    def write_rfc822(self, f: IO, entries: Iterable) -> None:
-        for entry in entries:
-            for key, value in entry.items():
-                if value:
-                    f.write(u"%s: %s\n" % (key, value))
-            f.write('\n')
-
 
 class Gencontrol(object):
     config: ConfigMerged
@@ -381,7 +374,7 @@ class Gencontrol(object):
         self.config, self.templates = config, templates
         self.changelog = Changelog(version=version)
         self.vars = {}
-        self.bundles = {'': PackagesBundle(None, templates)}
+        self.bundles = {}
 
     @property
     def bundle(self) -> PackagesBundle:
@@ -395,10 +388,10 @@ class Gencontrol(object):
         self.write()
 
     def do_source(self) -> None:
-        source = self.templates.get_source_control("source.control", self.vars)[0]
-        if not source.get('Source'):
-            source['Source'] = self.changelog[0].source
-        self.bundle.packages['source'] = source
+        self.bundles[''] = PackagesBundle(
+            None, 'source.control', self.vars, self.templates,
+            override_name=self.changelog[0].source,
+        )
 
     def do_main(self) -> None:
         vars = self.vars.copy()
@@ -645,10 +638,7 @@ class Gencontrol(object):
     ) -> None:
         pass
 
-    def substitute(self, s: str | list | tuple, vars) -> str | list:
-        if isinstance(s, (list, tuple)):
-            return [self.substitute(i, vars) for i in s]
-
+    def substitute(self, s: str, vars) -> str:
         def subst(match) -> str:
             return vars[match.group(1)]
 
diff --git a/debian/lib/python/debian_linux/test_debian.py b/debian/lib/python/debian_linux/test_debian.py
index 06133dc46e..73a18dfa89 100644
--- a/debian/lib/python/debian_linux/test_debian.py
+++ b/debian/lib/python/debian_linux/test_debian.py
@@ -237,7 +237,7 @@ class TestPackageDescription:
 
     def test_str(self) -> None:
         a = PackageDescription('Short\nLong1\n.\nLong2')
-        assert str(a) == 'Short\n Long1\n .\n Long2'
+        assert str(a) == 'Short\nLong1\n.\nLong2'
 
 
 class TestPackageRelationEntry:
diff --git a/debian/lib/python/debian_linux/utils.py b/debian/lib/python/debian_linux/utils.py
index 0c6569b5a0..661a730476 100644
--- a/debian/lib/python/debian_linux/utils.py
+++ b/debian/lib/python/debian_linux/utils.py
@@ -6,6 +6,7 @@ import typing
 
 import jinja2
 
+from .dataclasses_deb822 import read_deb822
 from .debian import SourcePackage, BinaryPackage, TestsControl
 
 
@@ -60,14 +61,20 @@ class Templates(object):
 
         return value[0]
 
-    def get_control(self, key: str, context: dict[str, str] = {}) -> BinaryPackage:
-        return BinaryPackage.read_rfc822(io.StringIO(self.get(key, context)))
+    def get_control(
+        self, key: str, context: dict[str, str] = {},
+    ) -> typing.Iterable[BinaryPackage]:
+        return read_deb822(BinaryPackage, io.StringIO(self.get(key, context)))
 
-    def get_source_control(self, key: str, context: dict[str, str] = {}) -> SourcePackage:
-        return SourcePackage.read_rfc822(io.StringIO(self.get(key, context)))
+    def get_source_control(
+        self, key: str, context: dict[str, str] = {},
+    ) -> typing.Iterable[SourcePackage]:
+        return read_deb822(SourcePackage, io.StringIO(self.get(key, context)))
 
-    def get_tests_control(self, key: str, context: dict[str, str] = {}) -> TestsControl:
-        return TestsControl.read_rfc822(io.StringIO(self.get(key, context)))
+    def get_tests_control(
+        self, key: str, context: dict[str, str] = {},
+    ) -> typing.Iterable[TestsControl]:
+        return read_deb822(TestsControl, io.StringIO(self.get(key, context)))
 
 
 class TextWrapper(textwrap.TextWrapper):