Ticket #12121: 12121.reduce_deferred.diff

django/db/models/base.py

@@ -344 +344 @@
     def __hash__(self):
         return hash(self._get_pk_val())
 
-    def __reduce__(self):
-        """
-        Provide pickling support. Normally, this just dispatches to Python's
-        standard handling. However, for models with deferred field loading, we
-        need to do things manually, as they're dynamically created classes and
-        only module-level classes can be pickled by the default path.
-        """
-        data = self.__dict__
-        if not self._deferred:
-            return super(Model, self).__reduce__()
-        defers = []
-        pk_val = None
-        for field in self._meta.fields:
-            if isinstance(self.__class__.__dict__.get(field.attname),
-                    DeferredAttribute):
-                defers.append(field.attname)
-                if pk_val is None:
-                    # The pk_val and model values are the same for all
-                    # DeferredAttribute classes, so we only need to do this
-                    # once.
-                    obj = self.__class__.__dict__[field.attname]
-                    model = obj.model_ref()
-
-        return (model_unpickle, (model, defers), data)
-
     def _get_pk_val(self, meta=None):
         if not meta:
             meta = self._meta
@@ -647 +622 @@
 class Empty(object):
     pass
 
-def model_unpickle(model, attrs):
-    """
-    Used to unpickle Model subclasses with deferred fields.
-    """
-    from django.db.models.query_utils import deferred_class_factory
-    cls = deferred_class_factory(model, attrs)
-    return cls.__new__(cls)
-model_unpickle.__safe_for_unpickle__ = True
-
 if sys.version_info < (2, 5):
     # Prior to Python 2.5, Exception was an old-style class
     def subclass_exception(name, parent, unused):

django/db/models/query_utils.py

@@ -237 +237 @@
     overrides["Meta"] = Meta
     overrides["__module__"] = model.__module__
     overrides["_deferred"] = True
+    overrides['__reduce__'] = deferred_model_reduce
     return type(name, (model,), overrides)
+deferred_class_factory.__safe_for_unpickling__ = True
 
-# The above function is also used to unpickle model instances with deferred
-# fields.
-deferred_class_factory.__safe_for_unpickling__ = True
+def deferred_model_reduce(self):
+    data = self.__dict__
+    defers = []
+    pk_val = None
+    for field in self._meta.fields:
+        if isinstance(self.__class__.__dict__.get(field.attname),
+                DeferredAttribute):
+            defers.append(field.attname)
+            if pk_val is None:
+                # The pk_val and model values are the same for all
+                # DeferredAttribute classes, so we only need to do this
+                # once.
+                obj = self.__class__.__dict__[field.attname]
+                model = obj.model_ref()
+
+    return (deferred_model_unpickle, (model, defers), data)
+
+def deferred_model_unpickle(model, attrs):
+    cls = deferred_class_factory(model, attrs)
+    return cls.__new__(cls)
+deferred_model_unpickle.__safe_for_unpickle__ = True
+