Debian Codegraph @

src/frozendict/cool.py

raw
1 from types import MappingProxyType
2 from array import array
3 from frozendict import frozendict
4 from collections.abc import MutableMapping, MutableSequence, MutableSet
5 from enum import Enum
6
7 # fix for python 3.9-
8
9 # coverage does not work here!
10 if not issubclass(array, MutableSequence): # pragma: no cover
11 # noinspection PyUnresolvedReferences
12 MutableSequence.register(array)
13
14
15 def isIterableNotString(o):
16 from collections import abc
17
18 return (
19 isinstance(o, abc.Iterable) and
20 not isinstance(o, memoryview) and
21 not hasattr(o, "isalpha")
22 )
23
24
25 def getItems(o):
26 from collections import abc
27
28 if not isinstance(o, abc.Iterable):
29 raise TypeError("object must be an iterable")
30
31 if isinstance(o, abc.Mapping):
32 return dict.items
33
34 return enumerate
35
36
37 def nil(x):
38 return x
39
40
41 _freeze_conversion_map = frozendict({
42 MutableMapping: frozendict,
43 bytearray: bytes,
44 MutableSequence: tuple,
45 MutableSet: frozenset,
46 Enum: nil,
47 })
48
49 _freeze_conversion_map_custom = {}
50
51
52 class FreezeError(Exception):
53 pass
54
55
56 class FreezeWarning(UserWarning):
57 pass
58
59
60 def register(to_convert, converter, *, inverse = False):
61 r"""
62 Adds a `converter` for a type `to_convert`. `converter`
63 must be callable. The new converter will be used by `deepfreeze()`
64 and has precedence over any previous converter.
65
66 If `to_covert` has already a converter, a FreezeWarning is raised.
67
68 If `inverse` is True, the conversion is considered from an immutable
69 type to a mutable one. This make it possible to convert mutable
70 objects nested in the registered immutable one.
71 """
72
73 if not issubclass(type(to_convert), type):
74 raise ValueError(
75 f"`to_convert` parameter must be a type, {to_convert} found"
76 )
77
78 try:
79 converter.__call__
80 except AttributeError:
81 raise ValueError(
82 f"`converter` parameter must be a callable, {converter}" +
83 "found"
84 )
85
86 if inverse:
87 freeze_conversion_map = getFreezeConversionInverseMap()
88 else:
89 freeze_conversion_map = getFreezeConversionMap()
90
91 if to_convert in freeze_conversion_map:
92 import warnings
93
94 warnings.warn(
95 f"{to_convert.__name__} is already in the conversion map",
96 FreezeWarning
97 )
98
99 if inverse:
100 freeze_conversion_map = _freeze_conversion_inverse_map_custom
101 else:
102 freeze_conversion_map = _freeze_conversion_map_custom
103
104 freeze_conversion_map[to_convert] = converter
105
106
107 def unregister(type, inverse = False):
108 r"""
109 Unregister a type from custom conversion. If `inverse` is `True`,
110 the unregistered conversion is an inverse conversion
111 (see `register()`).
112 """
113
114 if inverse:
115 freeze_conversion_map = _freeze_conversion_inverse_map_custom
116 else:
117 freeze_conversion_map = _freeze_conversion_map_custom
118
119 try:
120 del freeze_conversion_map[type]
121 except KeyError:
122 raise FreezeError(f"{type.__name__} is not registered")
123
124
125 def getFreezeConversionMap():
126 return _freeze_conversion_map | _freeze_conversion_map_custom
127
128
129 _freeze_conversion_inverse_map = frozendict({
130 frozendict: dict,
131 MappingProxyType: dict,
132 tuple: list,
133 })
134
135 _freeze_conversion_inverse_map_custom = {}
136
137
138 def getFreezeConversionInverseMap():
139 return (
140 _freeze_conversion_inverse_map |
141 _freeze_conversion_inverse_map_custom
142 )
143
144
145 _freeze_types = (
146 [x for x in _freeze_conversion_map] +
147 [x for x in _freeze_conversion_inverse_map]
148 )
149
150
151 def getFreezeTypes():
152 return (tuple(
153 _freeze_types +
154 [x for x in _freeze_conversion_map_custom] +
155 [x for x in _freeze_conversion_inverse_map_custom]
156 ))
157
158
159 _freeze_types_plain = (MutableSet, bytearray, array)
160
161
162 def deepfreeze(
163 o,
164 custom_converters = None,
165 custom_inverse_converters = None
166 ):
167 r"""
168 Converts the object and all the objects nested in it in its
169 immutable counterparts.
170
171 The conversion map is in getFreezeConversionMap().
172
173 You can register a new conversion using `register()` You can also
174 pass a map of custom converters with `custom_converters` and a map
175 of custom inverse converters with `custom_inverse_converters`,
176 without using `register()`.
177
178 By default, if the type is not registered and has a `__dict__`
179 attribute, it's converted to the `frozendict` of that `__dict__`.
180
181 This function assumes that hashable == immutable (that is not
182 always true).
183
184 This function uses recursion, with all the limits of recursions in
185 Python.
186
187 Where is a good old tail call when you need it?
188 """
189
190 from frozendict import frozendict
191
192 if custom_converters is None:
193 custom_converters = frozendict()
194
195 if custom_inverse_converters is None:
196 custom_inverse_converters = frozendict()
197
198 for type_i, converter in custom_converters.items():
199 if not issubclass(type(type_i), type):
200 raise ValueError(
201 f"{type_i} in `custom_converters` parameter is not a " +
202 "type"
203 )
204
205 try:
206 converter.__call__
207 except AttributeError:
208 raise ValueError(
209 f"converter for {type_i} in `custom_converters` " +
210 "parameter is not a callable"
211 )
212
213 for type_i, converter in custom_inverse_converters.items():
214 if not issubclass(type(type_i), type):
215 raise ValueError(
216 f"{type_i} in `custom_inverse_converters` parameter " +
217 "is not a type"
218 )
219
220 try:
221 converter.__call__
222 except AttributeError:
223 raise ValueError(
224 f"converter for {type_i} in " +
225 "`custom_inverse_converters`parameter is not a callable"
226 )
227
228 type_o = type(o)
229
230 freeze_types = tuple(custom_converters.keys()) + getFreezeTypes()
231
232 base_type_o = None
233
234 for freeze_type in freeze_types:
235 if isinstance(o, freeze_type):
236 base_type_o = freeze_type
237 break
238
239 if base_type_o is None:
240 # this is before hash check because all object in Python are
241 # hashable by default, if not explicitly suppressed
242 try:
243 o.__dict__
244 except AttributeError:
245 pass
246 else:
247 return frozendict(o.__dict__)
248
249 try:
250 hash(o)
251 except TypeError:
252 pass
253 else:
254 # without a converter, we can only hope that
255 # hashable == immutable
256 return o
257
258 supported_types = ", ".join((x.__name__ for x in freeze_types))
259
260 err = (
261 f"type {type_o} is not hashable or is not equal or a " +
262 f"subclass of the supported types: {supported_types}"
263 )
264
265 raise TypeError(err)
266
267 freeze_conversion_map = getFreezeConversionMap()
268
269 freeze_conversion_map = freeze_conversion_map | custom_converters
270
271 if base_type_o in _freeze_types_plain:
272 return freeze_conversion_map[base_type_o](o)
273
274 if not isIterableNotString(o):
275 return freeze_conversion_map[base_type_o](o)
276
277 freeze_conversion_inverse_map = getFreezeConversionInverseMap()
278
279 freeze_conversion_inverse_map = (
280 freeze_conversion_inverse_map |
281 custom_inverse_converters
282 )
283
284 frozen_type = base_type_o in freeze_conversion_inverse_map
285
286 if frozen_type:
287 o = freeze_conversion_inverse_map[base_type_o](o)
288
289 from copy import copy
290
291 o_copy = copy(o)
292
293 for k, v in getItems(o_copy)(o_copy):
294 o_copy[k] = deepfreeze(
295 v,
296 custom_converters = custom_converters,
297 custom_inverse_converters = custom_inverse_converters
298 )
299
300 try:
301 freeze = freeze_conversion_map[base_type_o]
302 except KeyError:
303 if frozen_type:
304 freeze = type_o
305 else: # pragma: no cover
306 raise
307
308 return freeze(o_copy)
309
310
311 __all__ = (
312 deepfreeze.__name__,
313 register.__name__,
314 unregister.__name__,
315 getFreezeConversionMap.__name__,
316 getFreezeConversionInverseMap.__name__,
317 FreezeError.__name__,
318 FreezeWarning.__name__,
319 )
320
321 del MappingProxyType
322 del array
323 del frozendict
324 del MutableMapping
325 del MutableSequence
326 del MutableSet
327 del Enum