Debian Codegraph @

debian/lib/python/debian_linux/dataclasses_deb822.py

raw
1 from __future__ import annotations
2
3 import dataclasses
4 import re
5 from typing import (
6 Any,
7 Callable,
8 IO,
9 Iterable,
10 Optional,
11 overload,
12 TYPE_CHECKING,
13 )
14
15 if TYPE_CHECKING:
16 from _typeshed import DataclassInstance as _DataclassInstance
17
18
19 __all__ = [
20 'field_deb822',
21 'read_deb822',
22 'write_deb822',
23 'Deb822DecodeError',
24 ]
25
26
27 class Deb822Field[T]:
28 key: str
29 load: Optional[Callable[[str], T]]
30 dump: Optional[Callable[[T], str]]
31
32 def __init__(
33 self, *,
34 key: str,
35 load: Optional[Callable[[str], T]],
36 dump: Optional[Callable[[T], str]],
37 ) -> None:
38 self.key = key
39 self.load = load
40 self.dump = dump
41
42
43 # The return type T is technically wrong, but it allows checking if during
44 # runtime we get the correct type.
45 @overload
46 def field_deb822[T](
47 deb822_key: str,
48 /, *,
49 deb822_load: Optional[Callable[[str], T]] = None,
50 deb822_dump: Optional[Callable[[T], str]] = str,
51 default: T,
52 ) -> T:
53 ...
54
55
56 @overload
57 def field_deb822[T](
58 deb822_key: str,
59 /, *,
60 deb822_load: Optional[Callable[[str], T]] = None,
61 deb822_dump: Optional[Callable[[T], str]] = str,
62 default_factory: Callable[[], T],
63 ) -> T:
64 ...
65
66
67 @overload
68 def field_deb822[T](
69 deb822_key: str,
70 /, *,
71 deb822_load: Optional[Callable[[str], T]] = None,
72 deb822_dump: Optional[Callable[[T], str]] = str,
73 ) -> T:
74 ...
75
76
77 def field_deb822[T](
78 deb822_key: str,
79 /, *,
80 deb822_load: Optional[Callable[[str], T]] = None,
81 deb822_dump: Optional[Callable[[T], str]] = str,
82 default: Any = dataclasses.MISSING,
83 default_factory: Any = dataclasses.MISSING,
84 ) -> Any:
85 metadata: dict[str, Any] = {
86 'deb822': Deb822Field(
87 key=deb822_key,
88 load=deb822_load,
89 dump=deb822_dump,
90 ),
91 }
92
93 if default is not dataclasses.MISSING:
94 return dataclasses.field(
95 default=default,
96 metadata=metadata,
97 )
98 else:
99 return dataclasses.field(
100 default_factory=default_factory,
101 metadata=metadata,
102 )
103
104
105 class Deb822DecodeError(ValueError):
106 pass
107
108
109 class Deb822DecodeState[T: _DataclassInstance]:
110 cls: type[T]
111 fields: dict[str, dataclasses.Field]
112 ignore_unknown: bool
113
114 data: dict[Optional[dataclasses.Field], str]
115 current: Optional[dataclasses.Field]
116
117 _line_re = re.compile(r'''
118 ^
119 (
120 [ \t](?P<cont>.*)
121 |
122 (?P<key>[^: \t\n\r\f\v]+)\s*:\s*(?P<value>.*)
123 )
124 $
125 ''', re.VERBOSE)
126
127 def __init__(
128 self,
129 cls: type[T],
130 ignore_unknown: bool,
131 ) -> None:
132 self.reset()
133
134 self.cls = cls
135 self.fields = {}
136 self.ignore_unknown = ignore_unknown
137
138 for i in dataclasses.fields(cls):
139 if i.init and (deb822_field := i.metadata.get('deb822')):
140 self.fields[deb822_field.key] = i
141
142 def reset(self) -> None:
143 self.data = {}
144 self.current = None
145
146 def line(self, linenr: int, line: str) -> None:
147 m = self._line_re.match(line)
148 if not m:
149 raise Deb822DecodeError(
150 f'Not a header, not a continuation at line {linenr + 1}')
151 elif cont := m.group('cont'):
152 self.data[self.current] += '\n' + cont
153 elif deb822_key := m.group('key'):
154 field = self.fields.get(deb822_key)
155 if not field and not self.ignore_unknown:
156 raise Deb822DecodeError(
157 f'Unknown field "{deb822_key}" at line {linenr + 1}')
158
159 self.current = field
160 self.data[field] = m.group('value')
161 else:
162 raise NotImplementedError
163
164 def generate(self) -> T | None:
165 if not self.data:
166 return None
167
168 r: dict[str, Any] = {}
169 for field, value in self.data.items():
170 field_factory: Optional[Callable[[str], Any]] = None
171 if field is None:
172 continue
173 elif (deb822_field := field.metadata.get('deb822')) and (load := deb822_field.load):
174 field_factory = load
175 elif isinstance(field.default_factory, type):
176 field_factory = field.default_factory
177 elif field.type in ('str', 'Optional[str]'):
178 field_factory = str
179 else:
180 raise RuntimeError(f'Unable to parse type {field.type}')
181
182 if field_factory is not None:
183 r[field.name] = field_factory(value)
184
185 self.reset()
186 return self.cls(**r)
187
188
189 def read_deb822[T: _DataclassInstance](
190 cls: type[T],
191 file: IO[str],
192 /,
193 ignore_unknown: bool = False,
194 ) -> Iterable[T]:
195 state = Deb822DecodeState(cls, ignore_unknown)
196
197 for linenr, line in enumerate(file):
198 line = line.rstrip('\n')
199
200 # Empty line, end of record
201 if line == '':
202 if (obj := state.generate()):
203 yield obj
204 # Strip comments rather than trying to preserve them
205 elif line[0] == '#':
206 continue
207 else:
208 state.line(linenr, line)
209
210 if (obj := state.generate()):
211 yield obj
212
213
214 def write_deb822[T: _DataclassInstance](
215 objs: Iterable[T],
216 file: IO[str],
217 /,
218 ) -> None:
219 for obj in objs:
220 for field in dataclasses.fields(obj):
221 if (
222 (value := getattr(obj, field.name, None))
223 and (deb822_field := field.metadata.get('deb822'))
224 and (dump := deb822_field.dump) is not None
225 ):
226 folded = '\n '.join(dump(value).strip().split('\n'))
227 file.write(f'{deb822_field.key}: {folded}\n')
228 file.write('\n')