                                     (field.model._meta.object_name, field.name))
      return True
  
  
  # This function is needed because data descriptors must be defined on a class
  # object, not an instance, to have any effect.
  
  def deferred_class_factory(model, attrs):
      """
      Returns a class object that is a copy of "model" with the specified "attrs"
      being replaced with DeferredAttribute objects. The "pk_value" ties the
      deferred attributes to a particular instance of the model.
      """
      if not attrs:
          return model
      opts = model._meta
      # Never create deferred models based on deferred model
      if model._deferred:
          # Deferred models are proxies for the non-deferred model. We never
          # create chains of defers => proxy_for_model is the non-deferred
          # model.
          model = opts.proxy_for_model
      # The app registry wants a unique name for each model, otherwise the new
      # class won't be created (we get an exception). Therefore, we generate
      # the name using the passed in attrs. It's OK to reuse an existing class
      # object if the attrs are identical.
      name = "%s_Deferred_%s" % (model.__name__, '_'.join(sorted(attrs)))
      name = utils.truncate_name(name, 80, 32)
  
      try:
          return opts.apps.get_model(model._meta.app_label, name)
  
      except LookupError:
  
          class Meta:
              proxy = True
              apps = opts.apps
              app_label = opts.app_label
  
          overrides = {attr: DeferredAttribute(attr, model) for attr in attrs}
          overrides["Meta"] = Meta
          overrides["__module__"] = model.__module__
          overrides["_deferred"] = True
          return type(str(name), (model,), overrides)
  
  
  def refs_expression(lookup_parts, annotations):
      """
      A helper method to check if the lookup_parts contains references
      to the given annotations set. Because the LOOKUP_SEP is contained in the
      default annotation names we must check each prefix of the lookup_parts
 
</s> remove ``field_names`` are in the same order as the ``values``, so it is possible to
use ``cls(**(zip(field_names, values)))`` to instantiate the object. If all
of the model's fields are present, then ``values`` are guaranteed to be in
the order ``__init__()`` expects them. That is, the instance can be created
by ``cls(*values)``. It is possible to check if all fields are present by
consulting ``cls._deferred`` - if ``False``, then all fields have been loaded
from the database.
 </s> add ``field_names`` are in the same order as the ``values``. If all of the model's
fields are present, then ``values`` are guaranteed to be in the order
``__init__()`` expects them. That is, the instance can be created by
``cls(*values)``. If any fields are deferred, they won't appear in
``field_names``. In that case, assign a value of ``django.db.models.DEFERRED``
to each of the missing fields. </s> remove         if self.model._deferred:
            # Deferred model will not be found from the app registry. This
            # could be fixed by reconstructing the deferred model on unpickle.
            raise RuntimeError("Fields of deferred models can't be reduced")
 </s> add  </s> remove         non_deferred_model = instance._meta.proxy_for_model
        opts = non_deferred_model._meta

        assert instance is not None
 </s> add         if instance is None:
            return self
        opts = instance._meta </s> remove         # default implementation of from_db() (could be replaced
        # with super())
        if cls._deferred:
            instance = cls(**zip(field_names, values))
        else:
            instance = cls(*values)
 </s> add         # Default implementation of from_db() (subject to change and could
        # be replaced with super()).
        if len(values) != len(cls._meta.concrete_fields):
            values = list(values)
            values.reverse()
            values = [
                values.pop() if f.attname in field_names else DEFERRED
                for f in cls._meta.concrete_fields
            ]
        new = cls(*values) </s> remove         count = 0
        for field in obj._meta.fields:
            if isinstance(obj.__class__.__dict__.get(field.attname), DeferredAttribute):
                count += 1
 </s> add         count = len(obj.get_deferred_fields())
                                     (field.model._meta.object_name, field.name))
      return True
  
  










































  def refs_expression(lookup_parts, annotations):
      """
      A helper method to check if the lookup_parts contains references
      to the given annotations set. Because the LOOKUP_SEP is contained in the
      default annotation names we must check each prefix of the lookup_parts
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 Fixed #26207 -- Replaced dynamic classes with non-data descriptors for deferred instance loading. 
django/db/models/query_utils.py