serializer.py 14 KB

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