django-bulk-hooks 0.2.71__tar.gz → 0.2.73__tar.gz

{django_bulk_hooks-0.2.71 → django_bulk_hooks-0.2.73}/PKG-INFO

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

@@ -103,6 +103,9 @@ class HookDispatcher:
         # Get hooks sorted by priority (deterministic order)
         hooks = self.registry.get_hooks(changeset.model_cls, event)
 
+        logger.debug(f"🧵 DISPATCH: changeset.model_cls={changeset.model_cls.__name__}, event={event}")
+        logger.debug(f"🎣 HOOKS_FOUND: {len(hooks)} hooks for {changeset.model_cls.__name__}.{event}: {[f'{h[0].__name__}.{h[1]}' for h in hooks]}")
+
         if not hooks:
             return
 
@@ -148,12 +151,21 @@ class HookDispatcher:
 
         # Filter out hooks that have already been executed for this operation
         unique_hooks = []
+        skipped_hooks = []
         for handler_cls, method_name, condition, priority in hooks:
             hook_key = (handler_cls, method_name, operation_key)
             if hook_key not in self._executed_hooks:
                 unique_hooks.append((handler_cls, method_name, condition, priority))
                 self._executed_hooks.add(hook_key)
+            else:
+                skipped_hooks.append((handler_cls.__name__, method_name))
+
+        # Debug logging for hook deduplication
+        if skipped_hooks:
+            logger.debug(f"⏭️ SKIPPED_DUPS: {len(skipped_hooks)} duplicate hooks: {[f'{cls}.{method}' for cls, method in skipped_hooks]}")
 
+        if unique_hooks:
+            logger.debug(f"✅ EXECUTING_UNIQUE: {len(unique_hooks)} unique hooks: {[f'{h[0].__name__}.{h[1]}' for h in unique_hooks]}")
 
         if not unique_hooks:
             return
@@ -179,13 +191,17 @@ class HookDispatcher:
             changeset: ChangeSet with all record changes
             event: The hook event (e.g., 'before_create')
         """
-        # NEW: Preload relationships needed for condition evaluation
+        # Preload relationships needed for condition evaluation (skip if already done upfront)
         if condition:
-            condition_relationships = self._extract_condition_relationships(condition, changeset.model_cls)
-            logger.info(f"🔍 CONDITION: {handler_cls.__name__}.{method_name} has condition, extracted relationships: {condition_relationships}")
-            if condition_relationships:
-                logger.info(f"🔗 PRELOADING: Preloading condition relationships for {len(changeset.changes)} records")
-                self._preload_condition_relationships(changeset, condition_relationships)
+            # Skip per-hook preloading if relationships were already preloaded upfront
+            if not changeset.operation_meta.get('relationships_preloaded', False):
+                condition_relationships = self._extract_condition_relationships(condition, changeset.model_cls)
+                logger.info(f"🔍 CONDITION: {handler_cls.__name__}.{method_name} has condition, extracted relationships: {condition_relationships}")
+                if condition_relationships:
+                    logger.info(f"🔗 PRELOADING: Preloading condition relationships for {len(changeset.changes)} records")
+                    self._preload_condition_relationships(changeset, condition_relationships)
+            else:
+                logger.debug(f"🔍 CONDITION: {handler_cls.__name__}.{method_name} has condition (relationships already preloaded)")
 
         # Filter records based on condition (now safe - relationships are preloaded)
         if condition:

{django_bulk_hooks-0.2.71 → django_bulk_hooks-0.2.73}/django_bulk_hooks/operations/coordinator.py

@@ -142,8 +142,11 @@ class BulkOperationCoordinator:
             event_suffix: Event name suffix (e.g., 'before_create', 'validate_update')
             bypass_hooks: Whether to skip hook execution
         """
-        for model_cls in models_in_chain:
+        logger.debug(f"🔄 DISPATCH_MODELS: Iterating through {len(models_in_chain)} models for {event_suffix}: {[m.__name__ for m in models_in_chain]}")
+        for i, model_cls in enumerate(models_in_chain):
+            logger.debug(f"🔄 DISPATCH_ITERATION: {i+1}/{len(models_in_chain)} - Dispatching to {model_cls.__name__} for {event_suffix}")
             model_changeset = self._build_changeset_for_model(changeset, model_cls)
+            logger.debug(f"🔄 CHANGESET_MODEL: Created changeset with model_cls={model_changeset.model_cls.__name__}")
             self.dispatcher.dispatch(model_changeset, event_suffix, bypass_hooks=bypass_hooks)
 
     # ==================== PUBLIC API ====================
@@ -702,9 +705,22 @@ class BulkOperationCoordinator:
 
         # Reset hook execution tracking for this new operation
         self.dispatcher._reset_executed_hooks()
+        logger.debug(f"🚀 MTI_OPERATION_START: {event_prefix} operation for {changeset.model_cls.__name__}")
 
         # Get all models in inheritance chain
         models_in_chain = self._get_models_in_chain(changeset.model_cls)
+        logger.debug(f"🔗 MTI_CHAIN_START: {len(models_in_chain)} models in chain for {changeset.model_cls.__name__}")
+
+        # Extract and preload relationships needed by hook conditions upfront
+        # This prevents duplicate queries by avoiding per-hook preloading
+        condition_relationships = self._extract_condition_relationships_for_operation(changeset, models_in_chain)
+        if condition_relationships:
+            logger.info(f"🔗 BULK PRELOAD: Preloading {len(condition_relationships)} condition relationships for {changeset.model_cls.__name__} hooks")
+            self.dispatcher._preload_condition_relationships(changeset, condition_relationships)
+            # Mark that relationships have been preloaded to avoid per-hook duplication
+            changeset.operation_meta['relationships_preloaded'] = True
+        else:
+            logger.info(f"🔗 BULK PRELOAD: No condition relationships to preload for {changeset.model_cls.__name__} hooks")
 
         # VALIDATE phase - for all models in chain
         if not bypass_validation:
@@ -799,6 +815,7 @@ class BulkOperationCoordinator:
             result_objects: List of objects returned from the operation
             models_in_chain: List of model classes in the MTI inheritance chain
         """
+        logger.debug(f"🔀 UPSERT_AFTER_START: Processing {len(result_objects)} result objects with {len(models_in_chain)} models in chain")
         # Split objects based on metadata set by the executor
         created_objects = []
         updated_objects = []
@@ -868,14 +885,18 @@ class BulkOperationCoordinator:
 
         # Dispatch after_create hooks for created objects
         if created_objects:
+            logger.debug(f"🔀 UPSERT_DISPATCH_CREATE: Dispatching after_create for {len(created_objects)} created objects")
             from django_bulk_hooks.helpers import build_changeset_for_create
 
             create_changeset = build_changeset_for_create(self.model_cls, created_objects)
+            # Mark that relationships have been preloaded to avoid per-hook duplication
+            create_changeset.operation_meta['relationships_preloaded'] = True
 
             self._dispatch_hooks_for_models(models_in_chain, create_changeset, "after_create", bypass_hooks=False)
 
         # Dispatch after_update hooks for updated objects
         if updated_objects:
+            logger.debug(f"🔀 UPSERT_DISPATCH_UPDATE: Dispatching after_update for {len(updated_objects)} updated objects")
             # Fetch old records for proper change detection
             old_records_map = self.analyzer.fetch_old_records_map(updated_objects)
 
@@ -887,12 +908,48 @@ class BulkOperationCoordinator:
                 update_kwargs={},  # Empty since we don't know specific fields
                 old_records_map=old_records_map,
             )
+            # Mark that relationships have been preloaded to avoid per-hook duplication
+            update_changeset.operation_meta['relationships_preloaded'] = True
 
             self._dispatch_hooks_for_models(models_in_chain, update_changeset, "after_update", bypass_hooks=False)
 
         # Clean up temporary metadata
         self._cleanup_upsert_metadata(result_objects)
 
+    def _extract_condition_relationships_for_operation(self, changeset, models_in_chain):
+        """
+        Extract relationships needed by hook conditions for this specific operation.
+
+        This is different from _extract_hook_relationships which gets ALL possible relationships
+        for queryset operations. This method only gets relationships needed by hooks that will
+        actually run in this operation.
+
+        Args:
+            changeset: The changeset for this operation
+            models_in_chain: List of model classes in inheritance chain
+
+        Returns:
+            set: Set of relationship field names to preload
+        """
+        relationships = set()
+        dispatcher = self.dispatcher
+
+        # Get the events that will run in this operation
+        event_prefix = changeset.operation_type
+        events_to_check = [f"validate_{event_prefix}", f"before_{event_prefix}", f"after_{event_prefix}"]
+
+        for model_cls in models_in_chain:
+            for event in events_to_check:
+                hooks = dispatcher.registry.get_hooks(model_cls, event)
+
+                for handler_cls, method_name, condition, priority in hooks:
+                    # Only extract relationships from conditions (not @select_related)
+                    if condition:
+                        condition_relationships = dispatcher._extract_condition_relationships(condition, model_cls)
+                        relationships.update(condition_relationships)
+
+        return relationships
+
     def _extract_hook_relationships(self):
         """
         Extract all relationship paths that hooks might access for this model and its MTI parents.

{django_bulk_hooks-0.2.71 → django_bulk_hooks-0.2.73}/django_bulk_hooks/operations/mti_handler.py

@@ -78,14 +78,17 @@ class MTIHandler:
         while current_model:
             if not current_model._meta.proxy and not current_model._meta.abstract:
                 chain.append(current_model)
+                logger.debug(f"🔗 MTI_CHAIN_ADD: Added {current_model.__name__} (abstract: {current_model._meta.abstract}, proxy: {current_model._meta.proxy})")
 
             # Get concrete parent models (not abstract, not proxy)
             parents = [parent for parent in current_model._meta.parents.keys() if not parent._meta.proxy and not parent._meta.abstract]
+            logger.debug(f"🔗 MTI_PARENTS: {current_model.__name__} has concrete parents: {[p.__name__ for p in parents]}")
 
             current_model = parents[0] if parents else None
 
         # Reverse to get root-to-child order
         chain.reverse()
+        logger.debug(f"🔗 MTI_CHAIN_FINAL: {[m.__name__ for m in chain]} (length: {len(chain)})")
         return chain
 
     def get_parent_models(self):

{django_bulk_hooks-0.2.71 → django_bulk_hooks-0.2.73}/pyproject.toml

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