Django lazy loading and LazyObject

Keywords: PHP Django Attribute

Looking at the login middleware, I found that request.user returned a SimpleOject object. Looking down, I turned to LazyObject. I didn't understand the source code for half a day.

After searching a lot of information on the Internet to find out what functions lazy loading implements, and then looking back at the source code, we may know the principle of LazyObject implementations.

Django's lazy loading means that objects are not instantiated when they are generated, and then instantiated when the properties or methods of the objects need to be invoked.

LazyObject source code:

empty = object()

#Implementing a generic lazy loading method for class methods, that is, checking whether an object is instantiated or not
#If it has not been instantiated, call the subclass instantiation method
#Finally, the original is invoked on the generated instance func Class method
def new_method_proxy(func):
    def inner(self, *args):
        if self._wrapped is empty:
        return func(self._wrapped, *args)
    return inner

class LazyObject:
    A wrapper for another class that can be used to delay instantiation of the
    wrapped class.

    By subclassing, you have the opportunity to intercept and alter the
    instantiation. If you don't need to do that, use SimpleLazyObject.

    # Avoid infinite recursion when tracing __init__ (#19456).
    _wrapped = None

    def __init__(self):
        # Note: if a subclass overrides __init__(), it will likely need to
        # override __copy__() and __deepcopy__() as well.
        self._wrapped = empty  #Whether tags are instantiated or not

    __getattr__ = new_method_proxy(getattr)  #Calling a generic delayed instantiation method

    def __setattr__(self, name, value):
        if name == "_wrapped": #If the amendment is_wrapped´╝îSpecial treatment
            # Assign to __dict__ to avoid infinite __setattr__ loops.
            self.__dict__["_wrapped"] = value
            if self._wrapped is empty:
            setattr(self._wrapped, name, value)   #After instantiation, modify the attributes of the instance

    def __delattr__(self, name):
        if name == "_wrapped":  #Not delete_wrapped attribute
            raise TypeError("can't delete _wrapped.")
        if self._wrapped is empty:
        delattr(self._wrapped, name)

    def _setup(self):
        Must be implemented by subclasses to initialize the wrapped object.
        #Callable only by subclasses
        raise NotImplementedError('subclasses of LazyObject must provide a _setup() method')

    # Because we have messed with __class__ below, we confuse pickle as to what
    # class we are pickling. We're going to have to initialize the wrapped
    # object to successfully pickle it, so we might as well just pickle the
    # wrapped object since they're supposed to act the same way.
    # Unfortunately, if we try to simply act like the wrapped object, the ruse
    # will break down when pickle gets our id(). Thus we end up with pickle
    # thinking, in effect, that we are a distinct object from the wrapped
    # object, but with the same __dict__. This can cause problems (see #25389).
    # So instead, we define our own __reduce__ method and custom unpickler. We
    # pickle the wrapped object as the unpickler's argument, so that pickle
    # will pickle it normally, and then the unpickler simply returns its
    # argument.
    def __reduce__(self):
        if self._wrapped is empty:
        return (unpickle_lazyobject, (self._wrapped,))

    def __copy__(self):
        if self._wrapped is empty:
            # If uninitialized, copy the wrapper. Use type(self), not
            # self.__class__, because the latter is proxied.
            return type(self)()
            # If initialized, return a copy of the wrapped object.
            return copy.copy(self._wrapped)

    def __deepcopy__(self, memo):
        if self._wrapped is empty:
            # We have to use type(self), not self.__class__, because the
            # latter is proxied.
            result = type(self)()
            memo[id(self)] = result
            return result
        return copy.deepcopy(self._wrapped, memo)

    __bytes__ = new_method_proxy(bytes)
    __str__ = new_method_proxy(str)
    __bool__ = new_method_proxy(bool)

    # Introspection support
    __dir__ = new_method_proxy(dir)

    # Need to pretend to be the wrapped class, for the sake of objects that
    # care about this (especially in equality tests)
    __class__ = property(new_method_proxy(operator.attrgetter("__class__")))
    __eq__ = new_method_proxy(operator.eq)
    __lt__ = new_method_proxy(
    __gt__ = new_method_proxy(
    __ne__ = new_method_proxy(
    __hash__ = new_method_proxy(hash)

    # List/Tuple/Dictionary methods support
    __getitem__ = new_method_proxy(operator.getitem)
    __setitem__ = new_method_proxy(operator.setitem)
    __delitem__ = new_method_proxy(operator.delitem)
    __iter__ = new_method_proxy(iter)
    __len__ = new_method_proxy(len)
    __contains__ = new_method_proxy(operator.contains)

Posted by Gwayn on Thu, 10 Oct 2019 15:35:49 -0700