django-bulk-hooks 0.2.42__tar.gz → 0.2.44__tar.gz

{django_bulk_hooks-0.2.42 → django_bulk_hooks-0.2.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.42
+Version: 0.2.44
 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.42 → django_bulk_hooks-0.2.44}/django_bulk_hooks/operations/bulk_executor.py

@@ -47,6 +47,8 @@ class BulkExecutor:
         update_conflicts=False,
         update_fields=None,
         unique_fields=None,
+        existing_record_ids=None,
+        existing_pks_map=None,
         **kwargs,
     ):
         """
@@ -74,11 +76,12 @@ class BulkExecutor:
         if self.mti_handler.is_mti_model():
             logger.info(f"Detected MTI model {self.model_cls.__name__}, using MTI bulk create")
 
-            # Classify records using the classifier service
-            existing_record_ids = set()
-            existing_pks_map = {}
-            if update_conflicts and unique_fields:
-                existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(objs, unique_fields)
+            # Use pre-classified records if provided, otherwise classify now
+            if existing_record_ids is None or existing_pks_map is None:
+                existing_record_ids = set()
+                existing_pks_map = {}
+                if update_conflicts and unique_fields:
+                    existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(objs, unique_fields)
 
             # Build execution plan with classification results
             plan = self.mti_handler.build_create_plan(
@@ -91,10 +94,16 @@ class BulkExecutor:
                 existing_pks_map=existing_pks_map,
             )
             # Execute the plan
-            return self._execute_mti_create_plan(plan)
+            result = self._execute_mti_create_plan(plan)
+            
+            # Tag objects with upsert metadata for hook dispatching
+            if update_conflicts and unique_fields:
+                self._tag_upsert_metadata(result, existing_record_ids)
+            
+            return result
 
         # Non-MTI model - use Django's native bulk_create
-        return self._execute_bulk_create(
+        result = self._execute_bulk_create(
             objs,
             batch_size,
             ignore_conflicts,
@@ -103,6 +112,15 @@ class BulkExecutor:
             unique_fields,
             **kwargs,
         )
+        
+        # Tag objects with upsert metadata for hook dispatching
+        if update_conflicts and unique_fields:
+            # Use pre-classified results if available, otherwise classify now
+            if existing_record_ids is None:
+                existing_record_ids, _ = self.record_classifier.classify_for_upsert(objs, unique_fields)
+            self._tag_upsert_metadata(result, existing_record_ids)
+        
+        return result
 
     def _execute_bulk_create(
         self,
@@ -510,3 +528,20 @@ class BulkExecutor:
         from django.db.models import QuerySet
 
         return QuerySet.delete(self.queryset)
+
+    def _tag_upsert_metadata(self, result_objects, existing_record_ids):
+        """
+        Tag objects with metadata indicating whether they were created or updated.
+        
+        This metadata is used by the coordinator to determine which hooks to fire.
+        The metadata is temporary and will be cleaned up after hook execution.
+        
+        Args:
+            result_objects: List of objects returned from bulk operation
+            existing_record_ids: Set of id() for objects that existed before the operation
+        """
+        for obj in result_objects:
+            # Tag with metadata for hook dispatching
+            was_created = id(obj) not in existing_record_ids
+            obj._bulk_hooks_was_created = was_created
+            obj._bulk_hooks_upsert_metadata = True

{django_bulk_hooks-0.2.42 → django_bulk_hooks-0.2.44}/django_bulk_hooks/operations/coordinator.py

@@ -133,6 +133,18 @@ class BulkOperationCoordinator:
         # Validate
         self.analyzer.validate_for_create(objs)
 
+        # For upsert operations, classify records upfront
+        existing_record_ids = set()
+        existing_pks_map = {}
+        if update_conflicts and unique_fields:
+            existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(
+                objs, unique_fields
+            )
+            logger.info(
+                f"Upsert operation: {len(existing_record_ids)} existing, "
+                f"{len(objs) - len(existing_record_ids)} new records"
+            )
+
         # Build initial changeset
         changeset = build_changeset_for_create(
             self.model_cls,
@@ -153,6 +165,8 @@ class BulkOperationCoordinator:
                 update_conflicts=update_conflicts,
                 update_fields=update_fields,
                 unique_fields=unique_fields,
+                existing_record_ids=existing_record_ids,
+                existing_pks_map=existing_pks_map,
             )
 
         return self._execute_with_mti_hooks(
@@ -627,13 +641,24 @@ class BulkOperationCoordinator:
         # AFTER phase - for all models in chain
         # Use result if operation returns modified data (for create operations)
         if result and isinstance(result, list) and event_prefix == "create":
-            # Rebuild changeset with assigned PKs for AFTER hooks
-            from django_bulk_hooks.helpers import build_changeset_for_create
-            changeset = build_changeset_for_create(changeset.model_cls, result)
-
-        for model_cls in models_in_chain:
-            model_changeset = self._build_changeset_for_model(changeset, model_cls)
-            self.dispatcher.dispatch(model_changeset, f"after_{event_prefix}", bypass_hooks=False)
+            # Check if this was an upsert operation
+            is_upsert = self._is_upsert_operation(result)
+            if is_upsert:
+                # Split hooks for upsert: after_create for created, after_update for updated
+                self._dispatch_upsert_after_hooks(result, models_in_chain)
+            else:
+                # Normal create operation
+                from django_bulk_hooks.helpers import build_changeset_for_create
+                changeset = build_changeset_for_create(changeset.model_cls, result)
+                
+                for model_cls in models_in_chain:
+                    model_changeset = self._build_changeset_for_model(changeset, model_cls)
+                    self.dispatcher.dispatch(model_changeset, f"after_{event_prefix}", bypass_hooks=False)
+        else:
+            # Non-create operations (update, delete)
+            for model_cls in models_in_chain:
+                model_changeset = self._build_changeset_for_model(changeset, model_cls)
+                self.dispatcher.dispatch(model_changeset, f"after_{event_prefix}", bypass_hooks=False)
 
         return result
 
@@ -668,3 +693,89 @@ class BulkOperationCoordinator:
                 continue
 
         return fk_relationships
+
+    def _is_upsert_operation(self, result_objects):
+        """
+        Check if the operation was an upsert (mixed create/update).
+        
+        Args:
+            result_objects: List of objects returned from the operation
+            
+        Returns:
+            True if this was an upsert operation, False otherwise
+        """
+        if not result_objects:
+            return False
+            
+        # Check if any object has upsert metadata
+        return hasattr(result_objects[0], '_bulk_hooks_upsert_metadata')
+
+    def _dispatch_upsert_after_hooks(self, result_objects, models_in_chain):
+        """
+        Dispatch after hooks for upsert operations, splitting by create/update.
+        
+        This matches Salesforce behavior:
+        - Records that were created fire after_create hooks
+        - Records that were updated fire after_update hooks
+        
+        Args:
+            result_objects: List of objects returned from the operation
+            models_in_chain: List of model classes in the MTI inheritance chain
+        """
+        # Split objects by operation type
+        created_objects = []
+        updated_objects = []
+        
+        for obj in result_objects:
+            was_created = getattr(obj, '_bulk_hooks_was_created', True)
+            if was_created:
+                created_objects.append(obj)
+            else:
+                updated_objects.append(obj)
+        
+        logger.info(
+            f"Upsert after hooks: {len(created_objects)} created, "
+            f"{len(updated_objects)} updated"
+        )
+        
+        # Dispatch after_create hooks for created objects
+        if created_objects:
+            from django_bulk_hooks.helpers import build_changeset_for_create
+            create_changeset = build_changeset_for_create(self.model_cls, created_objects)
+            
+            for model_cls in models_in_chain:
+                model_changeset = self._build_changeset_for_model(create_changeset, model_cls)
+                self.dispatcher.dispatch(model_changeset, "after_create", bypass_hooks=False)
+        
+        # Dispatch after_update hooks for updated objects
+        if updated_objects:
+            # Fetch old records for proper change detection
+            old_records_map = self.analyzer.fetch_old_records_map(updated_objects)
+            
+            from django_bulk_hooks.helpers import build_changeset_for_update
+            update_changeset = build_changeset_for_update(
+                self.model_cls,
+                updated_objects,
+                update_kwargs={},  # Empty since we don't know specific fields
+                old_records_map=old_records_map,
+            )
+            
+            for model_cls in models_in_chain:
+                model_changeset = self._build_changeset_for_model(update_changeset, model_cls)
+                self.dispatcher.dispatch(model_changeset, "after_update", bypass_hooks=False)
+        
+        # Clean up temporary metadata
+        self._cleanup_upsert_metadata(result_objects)
+
+    def _cleanup_upsert_metadata(self, result_objects):
+        """
+        Clean up temporary metadata added during upsert operations.
+        
+        Args:
+            result_objects: List of objects to clean up
+        """
+        for obj in result_objects:
+            if hasattr(obj, '_bulk_hooks_was_created'):
+                delattr(obj, '_bulk_hooks_was_created')
+            if hasattr(obj, '_bulk_hooks_upsert_metadata'):
+                delattr(obj, '_bulk_hooks_upsert_metadata')

{django_bulk_hooks-0.2.42 → django_bulk_hooks-0.2.44}/django_bulk_hooks/operations/mti_handler.py

@@ -259,11 +259,17 @@ class MTIHandler:
                         uf for uf in (update_fields or []) if uf in model_fields_by_name
                     ]
 
-                    # Enable upsert even if no fields to update at this level
-                    # This prevents unique constraint violations on parent tables
-                    level_update_conflicts = True
-                    level_unique_fields = normalized_unique
-                    level_update_fields = filtered_updates  # Can be empty list
+                    # If no fields to update at this level but we need upsert to prevent
+                    # unique constraint violations, use one of the unique fields as a dummy
+                    # update field (updating it to itself is a safe no-op)
+                    if not filtered_updates and normalized_unique:
+                        filtered_updates = [normalized_unique[0]]
+                    
+                    # Only enable upsert if we have fields to update (real or dummy)
+                    if filtered_updates:
+                        level_update_conflicts = True
+                        level_unique_fields = normalized_unique
+                        level_update_fields = filtered_updates
 
             # Create parent level
             parent_level = ParentLevel(

{django_bulk_hooks-0.2.42 → django_bulk_hooks-0.2.44}/django_bulk_hooks/registry.py

@@ -80,6 +80,7 @@ class HookRegistry:
         with self._lock:
             key = (model, event)
             hooks = self._hooks.get(key, [])
+            logger.debug(f"Retrieved {len(hooks)} hooks for {model.__name__}.{event}")
             return hooks
 
     def unregister(

{django_bulk_hooks-0.2.42 → django_bulk_hooks-0.2.44}/pyproject.toml

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