Minor change to get_extra_descriptor_filter()

                params = dict(

                    (rh_field.attname, getattr(instance, lh_field.attname))

                    for lh_field, rh_field in self.field.related_fields)

                params.update(self.field.get_extra_descriptor_filter(instance))

                qs = self.get_queryset(instance=instance)

                extra_filter = self.field.get_extra_descriptor_filter(instance)

                if isinstance(extra_filter, dict):

                    params.update(extra_filter)

                    qs = qs.filter(**params)

                else:

                    qs = qs.filter(extra_filter, **params)

                # Assuming the database enforces foreign keys, this won't fail.

                rel_obj = qs.get(**params)

                rel_obj = qs.get()

                if not self.field.rel.multiple:

                    setattr(rel_obj, self.field.related.get_cache_name(), instance)

            setattr(instance, self.cache_name, rel_obj)

        user does 'instance.fieldname', that is the extra filter is used in

        the descriptor of the field.

        The filter should be something usable in .filter(**kwargs) call, and

        will be ANDed together with the joining columns condition.

        The filter should be either a dict usable in .filter(**kwargs) call or

        a Q-object. The condition will be ANDed together with the relation's

        joining columns.

        A parallel method is get_extra_relation_restriction() which is used in

        A parallel method is get_extra_restriction() which is used in

        JOIN and subquery conditions.

        """

        return {}