django-bulk-hooks 0.2.62__tar.gz → 0.2.63__tar.gz

{django_bulk_hooks-0.2.62 → django_bulk_hooks-0.2.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.62
+Version: 0.2.63
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.2.62 → django_bulk_hooks-0.2.63}/django_bulk_hooks/dispatcher.py

@@ -122,7 +122,13 @@ class HookDispatcher:
             condition: Optional condition to filter records
             changeset: ChangeSet with all record changes
         """
-        # Filter records based on condition
+        # NEW: Preload relationships needed for condition evaluation
+        if condition:
+            condition_relationships = self._extract_condition_relationships(condition, changeset.model_cls)
+            if condition_relationships:
+                self._preload_condition_relationships(changeset, condition_relationships)
+
+        # Filter records based on condition (now safe - relationships are preloaded)
         if condition:
             filtered_changes = [change for change in changeset.changes if condition.check(change.new_record, change.old_record)]
 
@@ -204,6 +210,94 @@ class HookDispatcher:
             )
             raise
 
+    def _extract_condition_relationships(self, condition, model_cls):
+        """
+        Extract relationship paths that a condition might access.
+
+        Args:
+            condition: HookCondition instance
+            model_cls: The model class
+
+        Returns:
+            set: Set of relationship field names to preload
+        """
+        relationships = set()
+
+        # Guard against Mock objects and non-condition objects
+        if not hasattr(condition, 'check') or hasattr(condition, '_mock_name'):
+            return relationships
+
+        # Handle different condition types
+        if hasattr(condition, 'field'):
+            # Extract relationships from field path (e.g., "status__value" -> "status")
+            field_path = condition.field
+            if isinstance(field_path, str):
+                if '__' in field_path:
+                    # Take the first part before __ (the relationship to preload)
+                    rel_field = field_path.split('__')[0]
+                    relationships.add(rel_field)
+                elif self._is_relationship_field(model_cls, field_path):
+                    relationships.add(field_path)
+
+        # Handle composite conditions (AndCondition, OrCondition)
+        if hasattr(condition, 'cond1') and hasattr(condition, 'cond2'):
+            relationships.update(self._extract_condition_relationships(condition.cond1, model_cls))
+            relationships.update(self._extract_condition_relationships(condition.cond2, model_cls))
+
+        # Handle NotCondition
+        if hasattr(condition, 'cond'):
+            relationships.update(self._extract_condition_relationships(condition.cond, model_cls))
+
+        return relationships
+
+    def _is_relationship_field(self, model_cls, field_name):
+        """Check if a field is a relationship field."""
+        try:
+            field = model_cls._meta.get_field(field_name)
+            return field.is_relation and not field.many_to_many
+        except:
+            return False
+
+    def _preload_condition_relationships(self, changeset, relationships):
+        """
+        Preload relationships needed for condition evaluation.
+
+        Args:
+            changeset: ChangeSet with records
+            relationships: Set of relationship field names to preload
+        """
+        if not relationships or not changeset.new_records:
+            return
+
+        # Use Django's select_related to preload relationships
+        relationship_list = list(relationships)
+
+        # Preload for new_records
+        if changeset.new_records:
+            # Use select_related on the queryset
+            ids = [obj.pk for obj in changeset.new_records if obj.pk is not None]
+            if ids:
+                preloaded = changeset.model_cls.objects.filter(pk__in=ids).select_related(*relationship_list).in_bulk()
+                # Update the objects in changeset with preloaded relationships
+                for obj in changeset.new_records:
+                    if obj.pk and obj.pk in preloaded:
+                        preloaded_obj = preloaded[obj.pk]
+                        for rel in relationship_list:
+                            if hasattr(preloaded_obj, rel):
+                                setattr(obj, rel, getattr(preloaded_obj, rel))
+
+        # Also handle unsaved objects by preloading their FK targets
+        for obj in changeset.new_records:
+            if obj.pk is None:  # Unsaved object
+                for rel in relationship_list:
+                    if hasattr(obj, f'{rel}_id'):
+                        rel_id = getattr(obj, f'{rel}_id')
+                        if rel_id:
+                            # Load the related object
+                            rel_model = getattr(changeset.model_cls._meta.get_field(rel).remote_field, 'model')
+                            rel_obj = rel_model.objects.get(pk=rel_id)
+                            setattr(obj, rel, rel_obj)
+
 
 # Global dispatcher instance
 _dispatcher: HookDispatcher | None = None

{django_bulk_hooks-0.2.62 → django_bulk_hooks-0.2.63}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.2.62"
+version = "0.2.63"
 description = "Hook-style hooks for Django bulk operations like bulk_create and bulk_update."
 authors = ["Konrad Beck <konrad.beck@merchantcapital.co.za>"]
 readme = "README.md"