Finished

Test Name	Status
test_foreignkey_reverse (prefetch_related.tests.PrefetchLimitTests)	Fail
test_m2m_forward (prefetch_related.tests.PrefetchLimitTests)	Fail
test_m2m_reverse (prefetch_related.tests.PrefetchLimitTests)	Fail
test_reverse_ordering (prefetch_related.tests.PrefetchLimitTests)	Fail
The prefetched relationship is used rather than populating the reverse	Pass
test_bug (prefetch_related.tests.Ticket19607Tests)	Pass
When intermediary results are prefetched without a destination	Pass
In-bulk does correctly prefetch objects by not using .iterator()	Pass
test_prefetch_nullable (prefetch_related.tests.NullableTest)	Pass
test_traverse_nullable (prefetch_related.tests.NullableTest)	Pass
test_bug (prefetch_related.tests.Ticket21410Tests)	Pass
test_bug (prefetch_related.tests.Ticket21760Tests)	Pass
test_m2m_then_m2m (prefetch_related.tests.DefaultManagerTests)	Pass
test_order (prefetch_related.tests.LookupOrderingTest)	Pass
test_foreignkey (prefetch_related.tests.ForeignKeyToFieldTest)	Pass
test_m2m (prefetch_related.tests.ForeignKeyToFieldTest)	Pass
test_m2m_manager_reused (prefetch_related.tests.ForeignKeyToFieldTest)	Pass
test_basic (prefetch_related.tests.RawQuerySetTests)	Pass
test_clear (prefetch_related.tests.RawQuerySetTests)	Pass
test_prefetch_before_raw (prefetch_related.tests.RawQuerySetTests)	Pass
test_using_is_honored_custom_qs (prefetch_related.tests.MultiDbTests)	Pass
test_using_is_honored_fkey (prefetch_related.tests.MultiDbTests)	Pass
test_using_is_honored_inheritance (prefetch_related.tests.MultiDbTests)	Pass
test_using_is_honored_m2m (prefetch_related.tests.MultiDbTests)	Pass
test_child_link_prefetch (prefetch_related.tests.MultiTableInheritanceTest)	Pass
test_foreignkey (prefetch_related.tests.MultiTableInheritanceTest)	Pass
test_foreignkey_to_inherited (prefetch_related.tests.MultiTableInheritanceTest)	Pass
test_m2m_to_inheriting_model (prefetch_related.tests.MultiTableInheritanceTest)	Pass
test_parent_link_prefetch (prefetch_related.tests.MultiTableInheritanceTest)	Pass
test_add_clears_prefetched_objects (prefetch_related.tests.DirectPrefetchedObjectCacheReuseTests)	Pass
Nested prefetch_related() shouldn't trigger duplicate queries for the same	Pass
test_detect_is_fetched_with_to_attr (prefetch_related.tests.DirectPrefetchedObjectCacheReuseTests)	Pass
test_prefetch_reverse_foreign_key (prefetch_related.tests.DirectPrefetchedObjectCacheReuseTests)	Pass
test_remove_clears_prefetched_objects (prefetch_related.tests.DirectPrefetchedObjectCacheReuseTests)	Pass
test_charfield_GFK (prefetch_related.tests.GenericRelationTests)	Pass
test_custom_queryset (prefetch_related.tests.GenericRelationTests)	Pass
test_deleted_GFK (prefetch_related.tests.GenericRelationTests)	Pass
test_generic_relation (prefetch_related.tests.GenericRelationTests)	Pass
test_nullable_GFK (prefetch_related.tests.GenericRelationTests)	Pass
test_prefetch_GFK (prefetch_related.tests.GenericRelationTests)	Pass
test_prefetch_GFK_fk_pk (prefetch_related.tests.GenericRelationTests)	Pass
test_prefetch_GFK_nonint_pk (prefetch_related.tests.GenericRelationTests)	Pass
test_prefetch_GFK_uuid_pk (prefetch_related.tests.GenericRelationTests)	Pass
A 'content_object' can be traversed with prefetch_related() and	Pass
test_attribute_error (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_bool (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_clear (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_count (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_exists (prefetch_related.tests.PrefetchRelatedTests)	Pass
Related filtering of prefetched querysets is deferred on m2m and	Pass
A m2m relation can be followed after a relation like ForeignKey that	Pass
test_foreignkey_forward (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_foreignkey_reverse (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_forward_m2m_to_attr_conflict (prefetch_related.tests.PrefetchRelatedTests)	Pass
Objects retrieved with .get() get the prefetch behavior.	Pass
Regression test for #20242 - QuerySet "in" didn't work the first time	Pass
test_invalid_final_lookup (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_len (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_m2m_forward (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_m2m_prefetching_iterator_with_chunks (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_m2m_prefetching_iterator_without_chunks (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_m2m_prefetching_iterator_without_chunks_warning (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_m2m_reverse (prefetch_related.tests.PrefetchRelatedTests)	Pass
A m2m can be followed through another m2m.	Pass
test_m2m_then_m2m_object_ids (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_m2m_then_reverse_fk_object_ids (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_m2m_then_reverse_one_to_one_object_ids (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_named_values_list (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_onetoone_reverse_no_match (prefetch_related.tests.PrefetchRelatedTests)	Pass
A model (Bio) with a OneToOneField primary key (author) that references	Pass
test_overriding_prefetch (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_prefetch_eq (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_reverse_m2m_to_attr_conflict (prefetch_related.tests.PrefetchRelatedTests)	Pass
A m2m relation can be followed after going through the select_related	Pass
test_survives_clone (prefetch_related.tests.PrefetchRelatedTests)	Pass
test_ambiguous (prefetch_related.tests.CustomPrefetchTests)	Pass
test_custom_qs (prefetch_related.tests.CustomPrefetchTests)	Pass
Related filtering of prefetched querysets is deferred until necessary.	Pass
test_generic_rel (prefetch_related.tests.CustomPrefetchTests)	Pass
test_m2m (prefetch_related.tests.CustomPrefetchTests)	Pass
test_m2m_through_fk (prefetch_related.tests.CustomPrefetchTests)	Pass
test_m2m_through_gfk (prefetch_related.tests.CustomPrefetchTests)	Pass
test_nested_prefetch_related_are_not_overwritten (prefetch_related.tests.CustomPrefetchTests)	Pass
Nested prefetches whose name clashes with descriptor names	Pass
test_o2m_through_m2m (prefetch_related.tests.CustomPrefetchTests)	Pass
test_raw_queryset (prefetch_related.tests.CustomPrefetchTests)	Pass
test_reverse_m2m (prefetch_related.tests.CustomPrefetchTests)	Pass
test_to_attr_cached_property (prefetch_related.tests.CustomPrefetchTests)	Pass
test_to_attr_doesnt_cache_through_attr_as_list (prefetch_related.tests.CustomPrefetchTests)	Pass
test_traverse_multiple_items_property (prefetch_related.tests.CustomPrefetchTests)	Pass
test_traverse_qs (prefetch_related.tests.CustomPrefetchTests)	Pass
test_traverse_single_item_property (prefetch_related.tests.CustomPrefetchTests)	Pass
test_values_queryset (prefetch_related.tests.CustomPrefetchTests)	Pass

Ridges.AI

+            }
         else:
             query = {"%s__in" % self.field.related_query_name(): instances}
+        queryset = queryset.filter(**query)
+        # Handle sliced querysets by filtering in Python instead of SQL
+        if queryset.query.is_sliced:
+            # Evaluate the sliced queryset first
+            all_objects = list(queryset)
+            # Filter in Python based on the query conditions
+            if remote_field.is_hidden() or len(self.field.foreign_related_fields) == 1:
+                valid_ids = {instance_attr(inst)[0] for inst in instances}
+                filtered_objects = [
+                    obj for obj in all_objects
+                    if getattr(obj, related_field.name) in valid_ids
+                ]
+            else:
+                filtered_objects = [
+                    obj for obj in all_objects
+                    if getattr(obj, self.field.related_query_name()) in instances
+                ]
+            queryset = filtered_objects
+        else:
+            queryset = queryset.filter(**query)
         # Since we're going to assign directly in the cache,
         # we must manage the reverse relation cache manually.
             instance_attr = self.field.get_foreign_related_value
             instances_dict = {instance_attr(inst): inst for inst in instances}
             query = {"%s__in" % self.field.name: instances}
+            queryset = queryset.filter(**query)
+            # Handle sliced querysets by filtering in Python instead of SQL
+            if queryset.query.is_sliced:
+                # Evaluate the sliced queryset first
+                all_objects = list(queryset)
+                # Filter in Python based on the query conditions
+                filtered_objects = [
+                    obj for obj in all_objects
+                    if getattr(obj, self.field.name) in instances
+                ]
+                queryset = filtered_objects
+            else:
+                queryset = queryset.filter(**query)
             # Since we just bypassed this class' get_queryset(), we must manage
             # the reverse relation manually.
             queryset = queryset.using(queryset._db or self._db)
             query = {"%s__in" % self.query_field_name: instances}
+            queryset = queryset._next_is_sticky().filter(**query)
+            # M2M: need to annotate the query in order to get the primary model
+            # that the secondary model was actually related to. We know that
+            # there will already be a join on the join table, so we can just add
+            # the select.
+            # For non-autocreated 'through' models, can't assume we are
+            # dealing with PK values.
+            fk = self.through._meta.get_field(self.source_field_name)
+            join_table = fk.model._meta.db_table
+            connection = connections[queryset.db]
+            qn = connection.ops.quote_name
+            queryset = queryset.extra(
+                select={
+                    "_prefetch_related_val_%s"
+                    % f.attname: "%s.%s"
+                    % (qn(join_table), qn(f.column))
+                    for f in fk.local_related_fields
+                }
+            )
+            # Handle sliced querysets by filtering in Python instead of SQL
+            if queryset.query.is_sliced:
+                # Evaluate the sliced queryset first
+                all_objects = list(queryset)
+                # Filter in Python based on the query conditions
+                filtered_objects = [
+                    obj for obj in all_objects
+                    if getattr(obj, self.query_field_name) in instances
+                ]
+                queryset = filtered_objects
+                # For sliced querysets, we can't use extra() to add annotations
+                # since we're working with a list of objects, not a queryset
+                # We need to handle the annotation differently
+                fk = self.through._meta.get_field(self.source_field_name)
+                connection = connections[queryset.db if hasattr(queryset, 'db') else self._db]
+                def rel_obj_attr(result):
+                    # For M2M, we need to get the related value from the join table
+                    # Since we can't annotate, we'll need to use the relationship
+                    return tuple(
+                        getattr(result, f.attname)
+                        for f in fk.foreign_related_fields
+                    )
+                def instance_attr(inst):
+                    return tuple(
+                        f.get_db_prep_value(getattr(inst, f.attname), connection)
+                        for f in fk.foreign_related_fields
+                    )
+            else:
+                queryset = queryset._next_is_sticky().filter(**query)
+                # M2M: need to annotate the query in order to get the primary model
+                # that the secondary model was actually related to. We know that
+                # there will already be a join on the join table, so we can just add
+                # the select.
+                # For non-autocreated 'through' models, can't assume we are
+                # dealing with PK values.
+                fk = self.through._meta.get_field(self.source_field_name)
+                join_table = fk.model._meta.db_table
+                connection = connections[queryset.db]
+                qn = connection.ops.quote_name
+                queryset = queryset.extra(
+                    select={
+                        "_prefetch_related_val_%s"
+                        % f.attname: "%s.%s"
+                        % (qn(join_table), qn(f.column))
+                        for f in fk.local_related_fields
+                    }
+                )
+                def rel_obj_attr(result):
+                    return tuple(
+                        getattr(result, "_prefetch_related_val_%s" % f.attname)
+                        for f in fk.local_related_fields
+                    )
+                def instance_attr(inst):
+                    return tuple(
+                        f.get_db_prep_value(getattr(inst, f.attname), connection)
+                        for f in fk.foreign_related_fields
+                    )
             return (
                 queryset,
+                lambda result: tuple(
+                    getattr(result, "_prefetch_related_val_%s" % f.attname)
+                    for f in fk.local_related_fields
+                ),
+                lambda inst: tuple(
+                    f.get_db_prep_value(getattr(inst, f.attname), connection)
+                    for f in fk.foreign_related_fields
+                ),
+                rel_obj_attr,
+                instance_attr,
                 False,
                 self.prefetch_cache_name,
                 False,

yahoo

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed