Debian Codegraph @

django/db/migrations/serializer.py

raw
1 import builtins
2 import collections.abc
3 import datetime
4 import decimal
5 import enum
6 import functools
7 import math
8 import os
9 import pathlib
10 import re
11 import types
12 import uuid
13
14 from django.conf import SettingsReference
15 from django.db import models
16 from django.db.migrations.operations.base import Operation
17 from django.db.migrations.utils import COMPILED_REGEX_TYPE, RegexObject
18 from django.utils.functional import LazyObject, Promise
19 from django.utils.version import PY311, get_docs_version
20
21 FUNCTION_TYPES = (types.FunctionType, types.BuiltinFunctionType, types.MethodType)
22
23 if isinstance(functools._lru_cache_wrapper, type):
24 # When using CPython's _functools C module, LRU cache function decorators
25 # present as a class and not a function, so add that class to the list of
26 # function types. In the pure Python implementation and PyPy they present
27 # as normal functions which are already handled.
28 FUNCTION_TYPES += (functools._lru_cache_wrapper,)
29
30
31 class BaseSerializer:
32 def __init__(self, value):
33 self.value = value
34
35 def serialize(self):
36 raise NotImplementedError(
37 "Subclasses of BaseSerializer must implement the serialize() method."
38 )
39
40
41 class BaseSequenceSerializer(BaseSerializer):
42 def _format(self):
43 raise NotImplementedError(
44 "Subclasses of BaseSequenceSerializer must implement the _format() method."
45 )
46
47 def serialize(self):
48 imports = set()
49 strings = []
50 for item in self.value:
51 item_string, item_imports = serializer_factory(item).serialize()
52 imports.update(item_imports)
53 strings.append(item_string)
54 value = self._format()
55 return value % (", ".join(strings)), imports
56
57
58 class BaseUnorderedSequenceSerializer(BaseSequenceSerializer):
59 def __init__(self, value):
60 super().__init__(sorted(value, key=repr))
61
62
63 class BaseSimpleSerializer(BaseSerializer):
64 def serialize(self):
65 return repr(self.value), set()
66
67
68 class ChoicesSerializer(BaseSerializer):
69 def serialize(self):
70 return serializer_factory(self.value.value).serialize()
71
72
73 class DateTimeSerializer(BaseSerializer):
74 """For datetime.*, except datetime.datetime."""
75
76 def serialize(self):
77 return repr(self.value), {"import datetime"}
78
79
80 class DatetimeDatetimeSerializer(BaseSerializer):
81 """For datetime.datetime."""
82
83 def serialize(self):
84 if self.value.tzinfo is not None and self.value.tzinfo != datetime.timezone.utc:
85 self.value = self.value.astimezone(datetime.timezone.utc)
86 imports = ["import datetime"]
87 return repr(self.value), set(imports)
88
89
90 class DecimalSerializer(BaseSerializer):
91 def serialize(self):
92 return repr(self.value), {"from decimal import Decimal"}
93
94
95 class DeconstructableSerializer(BaseSerializer):
96 @staticmethod
97 def serialize_deconstructed(path, args, kwargs):
98 name, imports = DeconstructableSerializer._serialize_path(path)
99 strings = []
100 for arg in args:
101 arg_string, arg_imports = serializer_factory(arg).serialize()
102 strings.append(arg_string)
103 imports.update(arg_imports)
104 for kw, arg in sorted(kwargs.items()):
105 arg_string, arg_imports = serializer_factory(arg).serialize()
106 imports.update(arg_imports)
107 strings.append("%s=%s" % (kw, arg_string))
108 return "%s(%s)" % (name, ", ".join(strings)), imports
109
110 @staticmethod
111 def _serialize_path(path):
112 module, name = path.rsplit(".", 1)
113 if module == "django.db.models":
114 imports = {"from django.db import models"}
115 name = "models.%s" % name
116 else:
117 imports = {"import %s" % module}
118 name = path
119 return name, imports
120
121 def serialize(self):
122 return self.serialize_deconstructed(*self.value.deconstruct())
123
124
125 class DictionarySerializer(BaseSerializer):
126 def serialize(self):
127 imports = set()
128 strings = []
129 for k, v in sorted(self.value.items()):
130 k_string, k_imports = serializer_factory(k).serialize()
131 v_string, v_imports = serializer_factory(v).serialize()
132 imports.update(k_imports)
133 imports.update(v_imports)
134 strings.append((k_string, v_string))
135 return "{%s}" % (", ".join("%s: %s" % (k, v) for k, v in strings)), imports
136
137
138 class EnumSerializer(BaseSerializer):
139 def serialize(self):
140 enum_class = self.value.__class__
141 module = enum_class.__module__
142 if issubclass(enum_class, enum.Flag):
143 if PY311:
144 members = list(self.value)
145 else:
146 members, _ = enum._decompose(enum_class, self.value)
147 members = reversed(members)
148 else:
149 members = (self.value,)
150 return (
151 " | ".join(
152 [
153 f"{module}.{enum_class.__qualname__}[{item.name!r}]"
154 for item in members
155 ]
156 ),
157 {"import %s" % module},
158 )
159
160
161 class FloatSerializer(BaseSimpleSerializer):
162 def serialize(self):
163 if math.isnan(self.value) or math.isinf(self.value):
164 return 'float("{}")'.format(self.value), set()
165 return super().serialize()
166
167
168 class FrozensetSerializer(BaseUnorderedSequenceSerializer):
169 def _format(self):
170 return "frozenset([%s])"
171
172
173 class FunctionTypeSerializer(BaseSerializer):
174 def serialize(self):
175 if getattr(self.value, "__self__", None) and isinstance(
176 self.value.__self__, type
177 ):
178 klass = self.value.__self__
179 module = klass.__module__
180 return "%s.%s.%s" % (module, klass.__qualname__, self.value.__name__), {
181 "import %s" % module
182 }
183 # Further error checking
184 if self.value.__name__ == "<lambda>":
185 raise ValueError("Cannot serialize function: lambda")
186 if self.value.__module__ is None:
187 raise ValueError("Cannot serialize function %r: No module" % self.value)
188
189 module_name = self.value.__module__
190
191 if "<" not in self.value.__qualname__: # Qualname can include <locals>
192 return "%s.%s" % (module_name, self.value.__qualname__), {
193 "import %s" % self.value.__module__
194 }
195
196 raise ValueError(
197 "Could not find function %s in %s.\n" % (self.value.__name__, module_name)
198 )
199
200
201 class FunctoolsPartialSerializer(BaseSerializer):
202 def serialize(self):
203 # Serialize functools.partial() arguments
204 func_string, func_imports = serializer_factory(self.value.func).serialize()
205 args_string, args_imports = serializer_factory(self.value.args).serialize()
206 keywords_string, keywords_imports = serializer_factory(
207 self.value.keywords
208 ).serialize()
209 # Add any imports needed by arguments
210 imports = {"import functools", *func_imports, *args_imports, *keywords_imports}
211 return (
212 "functools.%s(%s, *%s, **%s)"
213 % (
214 self.value.__class__.__name__,
215 func_string,
216 args_string,
217 keywords_string,
218 ),
219 imports,
220 )
221
222
223 class IterableSerializer(BaseSerializer):
224 def serialize(self):
225 imports = set()
226 strings = []
227 for item in self.value:
228 item_string, item_imports = serializer_factory(item).serialize()
229 imports.update(item_imports)
230 strings.append(item_string)
231 # When len(strings)==0, the empty iterable should be serialized as
232 # "()", not "(,)" because (,) is invalid Python syntax.
233 value = "(%s)" if len(strings) != 1 else "(%s,)"
234 return value % (", ".join(strings)), imports
235
236
237 class ModelFieldSerializer(DeconstructableSerializer):
238 def serialize(self):
239 attr_name, path, args, kwargs = self.value.deconstruct()
240 return self.serialize_deconstructed(path, args, kwargs)
241
242
243 class ModelManagerSerializer(DeconstructableSerializer):
244 def serialize(self):
245 as_manager, manager_path, qs_path, args, kwargs = self.value.deconstruct()
246 if as_manager:
247 name, imports = self._serialize_path(qs_path)
248 return "%s.as_manager()" % name, imports
249 else:
250 return self.serialize_deconstructed(manager_path, args, kwargs)
251
252
253 class OperationSerializer(BaseSerializer):
254 def serialize(self):
255 from django.db.migrations.writer import OperationWriter
256
257 string, imports = OperationWriter(self.value, indentation=0).serialize()
258 # Nested operation, trailing comma is handled in upper OperationWriter._write()
259 return string.rstrip(","), imports
260
261
262 class PathLikeSerializer(BaseSerializer):
263 def serialize(self):
264 return repr(os.fspath(self.value)), {}
265
266
267 class PathSerializer(BaseSerializer):
268 def serialize(self):
269 # Convert concrete paths to pure paths to avoid issues with migrations
270 # generated on one platform being used on a different platform.
271 prefix = "Pure" if isinstance(self.value, pathlib.Path) else ""
272 return "pathlib.%s%r" % (prefix, self.value), {"import pathlib"}
273
274
275 class RegexSerializer(BaseSerializer):
276 def serialize(self):
277 regex_pattern, pattern_imports = serializer_factory(
278 self.value.pattern
279 ).serialize()
280 # Turn off default implicit flags (e.g. re.U) because regexes with the
281 # same implicit and explicit flags aren't equal.
282 flags = self.value.flags ^ re.compile("").flags
283 regex_flags, flag_imports = serializer_factory(flags).serialize()
284 imports = {"import re", *pattern_imports, *flag_imports}
285 args = [regex_pattern]
286 if flags:
287 args.append(regex_flags)
288 return "re.compile(%s)" % ", ".join(args), imports
289
290
291 class SequenceSerializer(BaseSequenceSerializer):
292 def _format(self):
293 return "[%s]"
294
295
296 class SetSerializer(BaseUnorderedSequenceSerializer):
297 def _format(self):
298 # Serialize as a set literal except when value is empty because {}
299 # is an empty dict.
300 return "{%s}" if self.value else "set(%s)"
301
302
303 class SettingsReferenceSerializer(BaseSerializer):
304 def serialize(self):
305 return "settings.%s" % self.value.setting_name, {
306 "from django.conf import settings"
307 }
308
309
310 class TupleSerializer(BaseSequenceSerializer):
311 def _format(self):
312 # When len(value)==0, the empty tuple should be serialized as "()",
313 # not "(,)" because (,) is invalid Python syntax.
314 return "(%s)" if len(self.value) != 1 else "(%s,)"
315
316
317 class TypeSerializer(BaseSerializer):
318 def serialize(self):
319 special_cases = [
320 (models.Model, "models.Model", ["from django.db import models"]),
321 (types.NoneType, "types.NoneType", ["import types"]),
322 ]
323 for case, string, imports in special_cases:
324 if case is self.value:
325 return string, set(imports)
326 if hasattr(self.value, "__module__"):
327 module = self.value.__module__
328 if module == builtins.__name__:
329 return self.value.__name__, set()
330 else:
331 return "%s.%s" % (module, self.value.__qualname__), {
332 "import %s" % module
333 }
334
335
336 class UUIDSerializer(BaseSerializer):
337 def serialize(self):
338 return "uuid.%s" % repr(self.value), {"import uuid"}
339
340
341 class Serializer:
342 _registry = {
343 # Some of these are order-dependent.
344 frozenset: FrozensetSerializer,
345 list: SequenceSerializer,
346 set: SetSerializer,
347 tuple: TupleSerializer,
348 dict: DictionarySerializer,
349 models.Choices: ChoicesSerializer,
350 enum.Enum: EnumSerializer,
351 datetime.datetime: DatetimeDatetimeSerializer,
352 (datetime.date, datetime.timedelta, datetime.time): DateTimeSerializer,
353 SettingsReference: SettingsReferenceSerializer,
354 float: FloatSerializer,
355 (bool, int, types.NoneType, bytes, str, range): BaseSimpleSerializer,
356 decimal.Decimal: DecimalSerializer,
357 (functools.partial, functools.partialmethod): FunctoolsPartialSerializer,
358 FUNCTION_TYPES: FunctionTypeSerializer,
359 collections.abc.Iterable: IterableSerializer,
360 (COMPILED_REGEX_TYPE, RegexObject): RegexSerializer,
361 uuid.UUID: UUIDSerializer,
362 pathlib.PurePath: PathSerializer,
363 os.PathLike: PathLikeSerializer,
364 }
365
366 @classmethod
367 def register(cls, type_, serializer):
368 if not issubclass(serializer, BaseSerializer):
369 raise ValueError(
370 "'%s' must inherit from 'BaseSerializer'." % serializer.__name__
371 )
372 cls._registry[type_] = serializer
373
374 @classmethod
375 def unregister(cls, type_):
376 cls._registry.pop(type_)
377
378
379 def serializer_factory(value):
380 if isinstance(value, Promise):
381 value = str(value)
382 elif isinstance(value, LazyObject):
383 # The unwrapped value is returned as the first item of the arguments
384 # tuple.
385 value = value.__reduce__()[1][0]
386
387 if isinstance(value, models.Field):
388 return ModelFieldSerializer(value)
389 if isinstance(value, models.manager.BaseManager):
390 return ModelManagerSerializer(value)
391 if isinstance(value, Operation):
392 return OperationSerializer(value)
393 if isinstance(value, type):
394 return TypeSerializer(value)
395 # Anything that knows how to deconstruct itself.
396 if hasattr(value, "deconstruct"):
397 return DeconstructableSerializer(value)
398 for type_, serializer_cls in Serializer._registry.items():
399 if isinstance(value, type_):
400 return serializer_cls(value)
401 raise ValueError(
402 "Cannot serialize: %r\nThere are some values Django cannot serialize into "
403 "migration files.\nFor more, see https://docs.djangoproject.com/en/%s/"
404 "topics/migrations/#migration-serializing" % (value, get_docs_version())
405 )