django-bulk-hooks 0.2.64__tar.gz → 0.2.66__tar.gz

{django_bulk_hooks-0.2.64 → django_bulk_hooks-0.2.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.64
+Version: 0.2.66
 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.64 → django_bulk_hooks-0.2.66}/django_bulk_hooks/dispatcher.py

@@ -110,9 +110,9 @@ class HookDispatcher:
         logger.info(f"🔥 HOOKS: Executing {len(hooks)} hooks for {changeset.model_cls.__name__}.{event}")
         for handler_cls, method_name, condition, priority in hooks:
             logger.info(f"  → {handler_cls.__name__}.{method_name} (priority={priority})")
-            self._execute_hook(handler_cls, method_name, condition, changeset)
+            self._execute_hook(handler_cls, method_name, condition, changeset, event)
 
-    def _execute_hook(self, handler_cls, method_name, condition, changeset):
+    def _execute_hook(self, handler_cls, method_name, condition, changeset, event):
         """
         Execute a single hook with condition checking.
 
@@ -121,6 +121,7 @@ class HookDispatcher:
             method_name: Name of the method to call
             condition: Optional condition to filter records
             changeset: ChangeSet with all record changes
+            event: The hook event (e.g., 'before_create')
         """
         # NEW: Preload relationships needed for condition evaluation
         if condition:
@@ -155,7 +156,13 @@ class HookDispatcher:
         handler = create_hook_instance(handler_cls)
         method = getattr(handler, method_name)
 
-        # Check if method has @select_related decorator
+        # SPECIAL HANDLING: Explicit @select_related support for BEFORE_CREATE hooks
+        # This provides guaranteed bulk preloading to eliminate N+1 queries
+        select_related_fields = getattr(method, "_select_related_fields", None)
+        if select_related_fields and event == "before_create" and filtered_changeset.new_records:
+            self._preload_select_related_for_before_create(filtered_changeset, select_related_fields)
+
+        # Check if method has @select_related decorator (fallback for other cases)
         preload_func = getattr(method, "_select_related_preload", None)
         if preload_func:
             # Preload relationships to prevent N+1 queries
@@ -316,6 +323,69 @@ class HookDispatcher:
                             rel_obj = rel_model.objects.get(pk=rel_id)
                             setattr(obj, rel, rel_obj)
 
+    def _preload_select_related_for_before_create(self, changeset, select_related_fields):
+        """
+        Explicit bulk preloading for @select_related on BEFORE_CREATE hooks.
+
+        This method provides guaranteed N+1 elimination by:
+        1. Collecting all FK IDs from unsaved new_records
+        2. Bulk querying related objects
+        3. Attaching relationships to each record
+
+        Args:
+            changeset: ChangeSet with new_records (unsaved objects)
+            select_related_fields: List of field names to preload (e.g., ['financial_account'])
+        """
+        if not select_related_fields or not changeset.new_records:
+            return
+
+        logger.info(f"🔗 BULK PRELOAD: Preloading {select_related_fields} for {len(changeset.new_records)} unsaved records")
+
+        # Collect FK IDs for each field
+        field_ids_map = {field: set() for field in select_related_fields}
+
+        for record in changeset.new_records:
+            for field in select_related_fields:
+                fk_id = getattr(record, f'{field}_id', None)
+                if fk_id is not None:
+                    field_ids_map[field].add(fk_id)
+
+        # Bulk query related objects for each field
+        field_objects_map = {}
+        for field, ids in field_ids_map.items():
+            if not ids:
+                continue
+
+            try:
+                # Get the related model
+                relation_field = changeset.model_cls._meta.get_field(field)
+                if not relation_field.is_relation:
+                    continue
+
+                related_model = relation_field.remote_field.model
+
+                # Bulk query: related_model.objects.filter(id__in=ids)
+                field_objects_map[field] = related_model.objects.in_bulk(ids)
+                logger.info(f"  ✅ Bulk loaded {len(field_objects_map[field])} {related_model.__name__} objects for field '{field}'")
+
+            except Exception as e:
+                logger.warning(f"  ❌ Failed to bulk load field '{field}': {e}")
+                field_objects_map[field] = {}
+
+        # Attach relationships to each record
+        for record in changeset.new_records:
+            for field in select_related_fields:
+                fk_id = getattr(record, f'{field}_id', None)
+                if fk_id is not None and field in field_objects_map:
+                    related_obj = field_objects_map[field].get(fk_id)
+                    if related_obj is not None:
+                        setattr(record, field, related_obj)
+                        # Also cache in Django's fields_cache for consistency
+                        if hasattr(record, '_state') and hasattr(record._state, 'fields_cache'):
+                            record._state.fields_cache[field] = related_obj
+
+        logger.info(f"🔗 BULK PRELOAD: Completed relationship attachment for {len(changeset.new_records)} records")
+
 
 # Global dispatcher instance
 _dispatcher: HookDispatcher | None = None

{django_bulk_hooks-0.2.64 → django_bulk_hooks-0.2.66}/django_bulk_hooks/helpers.py

@@ -52,11 +52,18 @@ def build_changeset_for_update(
     if old_records_map is None:
         old_records_map = {}
 
+    # Smart pre-computation logic:
+    # - If update_kwargs non-empty and old_records exist: Don't precompute (QuerySet.update case)
+    # - If update_kwargs empty and old_records exist: Don't precompute (upsert case)
+    # - If update_kwargs empty and no old_records: Precompute as empty (validation case)
+    should_precompute = not bool(update_kwargs) and old_records_map is None
+    changed_fields = list(update_kwargs.keys()) if should_precompute else None
+
     changes = [
         RecordChange(
             new,
             old_records_map.get(new.pk),
-            changed_fields=list(update_kwargs.keys()),
+            changed_fields=changed_fields,
         )
         for new in instances
     ]

{django_bulk_hooks-0.2.64 → django_bulk_hooks-0.2.66}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.2.64"
+version = "0.2.66"
 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"