django-bulk-hooks 0.2.43__tar.gz → 0.2.45__tar.gz

{django_bulk_hooks-0.2.43 → django_bulk_hooks-0.2.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.43
+Version: 0.2.45
 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.43 → django_bulk_hooks-0.2.45}/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,33 @@ 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
+        """
+        created_count = 0
+        updated_count = 0
+        
+        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
+            
+            if was_created:
+                created_count += 1
+            else:
+                updated_count += 1
+        
+        logger.info(
+            f"Tagged upsert metadata: {created_count} created, {updated_count} updated "
+            f"(total={len(result_objects)}, existing_ids={len(existing_record_ids)})"
+        )

{django_bulk_hooks-0.2.43 → django_bulk_hooks-0.2.45}/django_bulk_hooks/operations/coordinator.py

@@ -29,7 +29,6 @@ class BulkOperationCoordinator:
     Services are created lazily and cached.
     """
 
-
     def __init__(self, queryset):
         """
         Initialize coordinator for a queryset.
@@ -133,6 +132,15 @@ 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, {len(objs) - len(existing_record_ids)} new records")
+            logger.debug(f"Existing record IDs: {existing_record_ids}")
+            logger.debug(f"Existing PKs map: {existing_pks_map}")
+
         # Build initial changeset
         changeset = build_changeset_for_create(
             self.model_cls,
@@ -153,6 +161,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(
@@ -222,14 +232,17 @@ class BulkOperationCoordinator:
 
     @transaction.atomic
     def update_queryset(
-        self, update_kwargs, bypass_hooks=False, bypass_validation=False,
+        self,
+        update_kwargs,
+        bypass_hooks=False,
+        bypass_validation=False,
     ):
         """
         Execute queryset.update() with full hook support.
-        
+
         ARCHITECTURE & PERFORMANCE TRADE-OFFS
         ======================================
-        
+
         To support hooks with queryset.update(), we must:
         1. Fetch old state (SELECT all matching rows)
         2. Execute database update (UPDATE in SQL)
@@ -238,29 +251,29 @@ class BulkOperationCoordinator:
         5. Run BEFORE_UPDATE hooks (CAN modify instances)
         6. Persist BEFORE_UPDATE modifications (bulk_update)
         7. Run AFTER_UPDATE hooks (read-only side effects)
-        
+
         Performance Cost:
         - 2 SELECT queries (before/after)
         - 1 UPDATE query (actual update)
         - 1 bulk_update (if hooks modify data)
-        
+
         Trade-off: Hooks require loading data into Python. If you need
         maximum performance and don't need hooks, use bypass_hooks=True.
-        
+
         Hook Semantics:
         - BEFORE_UPDATE hooks run after the DB update and CAN modify instances
         - Modifications are auto-persisted (framework handles complexity)
         - AFTER_UPDATE hooks run after BEFORE_UPDATE and are read-only
         - This enables cascade logic and computed fields based on DB values
         - User expectation: BEFORE_UPDATE hooks can modify data
-        
+
         Why this approach works well:
         - Allows hooks to see Subquery/F() computed values
         - Enables HasChanged conditions on complex expressions
         - Maintains SQL performance (Subquery stays in database)
         - Meets user expectations: BEFORE_UPDATE can modify instances
         - Clean separation: BEFORE for modifications, AFTER for side effects
-        
+
         For true "prevent write" semantics, intercept at a higher level
         or use bulk_update() directly (which has true before semantics).
         """
@@ -277,19 +290,21 @@ class BulkOperationCoordinator:
         )
 
     def _execute_queryset_update_with_hooks(
-        self, update_kwargs, bypass_validation=False,
+        self,
+        update_kwargs,
+        bypass_validation=False,
     ):
         """
         Execute queryset update with full hook lifecycle support.
-        
+
         This method implements the fetch-update-fetch pattern required
         to support hooks with queryset.update(). BEFORE_UPDATE hooks can
         modify instances and modifications are auto-persisted.
-        
+
         Args:
             update_kwargs: Dict of fields to update
             bypass_validation: Skip validation hooks if True
-            
+
         Returns:
             Number of rows updated
         """
@@ -373,11 +388,11 @@ class BulkOperationCoordinator:
     def _run_before_update_hooks_with_tracking(self, instances, models_in_chain, changeset):
         """
         Run BEFORE_UPDATE hooks and detect modifications.
-        
+
         This is what users expect - BEFORE_UPDATE hooks can modify instances
         and those modifications will be automatically persisted. The framework
         handles the complexity internally.
-        
+
         Returns:
             Set of field names that were modified by hooks
         """
@@ -399,10 +414,10 @@ class BulkOperationCoordinator:
     def _snapshot_instance_state(self, instances):
         """
         Create a snapshot of current instance field values.
-        
+
         Args:
             instances: List of model instances
-            
+
         Returns:
             Dict mapping pk -> {field_name: value}
         """
@@ -432,11 +447,11 @@ class BulkOperationCoordinator:
     def _detect_modifications(self, instances, pre_hook_state):
         """
         Detect which fields were modified by comparing to snapshot.
-        
+
         Args:
             instances: List of model instances
             pre_hook_state: Previous state snapshot from _snapshot_instance_state
-            
+
         Returns:
             Set of field names that were modified
         """
@@ -463,16 +478,15 @@ class BulkOperationCoordinator:
     def _persist_hook_modifications(self, instances, modified_fields):
         """
         Persist modifications made by hooks using bulk_update.
-        
+
         This creates a "cascade" effect similar to Salesforce workflows.
-        
+
         Args:
             instances: List of modified instances
             modified_fields: Set of field names that were modified
         """
         logger.info(
-            f"Hooks modified {len(modified_fields)} field(s): "
-            f"{', '.join(sorted(modified_fields))}",
+            f"Hooks modified {len(modified_fields)} field(s): {', '.join(sorted(modified_fields))}",
         )
         logger.info("Auto-persisting modifications via bulk_update")
 
@@ -555,14 +569,14 @@ class BulkOperationCoordinator:
     def _build_changeset_for_model(self, original_changeset, target_model_cls):
         """
         Build a changeset for a specific model in the MTI inheritance chain.
-        
+
         This allows parent model hooks to receive the same instances but with
         the correct model_cls for hook registration matching.
-        
+
         Args:
             original_changeset: The original changeset (for child model)
             target_model_cls: The model class to build changeset for (parent model)
-            
+
         Returns:
             ChangeSet for the target model
         """
@@ -586,18 +600,18 @@ class BulkOperationCoordinator:
     ):
         """
         Execute operation with hooks for entire MTI inheritance chain.
-        
+
         This method dispatches hooks for both child and parent models when
         dealing with MTI models, ensuring parent model hooks fire when
         child instances are created/updated/deleted.
-        
+
         Args:
             changeset: ChangeSet for the child model
             operation: Callable that performs the actual DB operation
             event_prefix: 'create', 'update', or 'delete'
             bypass_hooks: Skip all hooks if True
             bypass_validation: Skip validation hooks if True
-            
+
         Returns:
             Result of operation
         """
@@ -627,13 +641,25 @@ 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
 
@@ -655,11 +681,13 @@ class BulkOperationCoordinator:
         for field_name in update_kwargs.keys():
             try:
                 field = self.model_cls._meta.get_field(field_name)
-                if (field.is_relation and
-                    not field.many_to_many and
-                    not field.one_to_many and
-                    hasattr(field, "attname") and
-                    field.attname == field_name):
+                if (
+                    field.is_relation
+                    and not field.many_to_many
+                    and not field.one_to_many
+                    and hasattr(field, "attname")
+                    and field.attname == field_name
+                ):
                     # This is a FK field being updated by its attname (e.g., business_id)
                     # Add the relationship name (e.g., 'business') to skip list
                     fk_relationships.add(field.name)
@@ -668,3 +696,107 @@ 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 = []
+        missing_metadata_count = 0
+        
+        for obj in result_objects:
+            # Check if metadata was set (it MUST be set for upsert operations)
+            if not hasattr(obj, '_bulk_hooks_upsert_metadata'):
+                # This should never happen - log and treat as created to maintain backward compat
+                missing_metadata_count += 1
+                logger.warning(
+                    f"Object {obj} (id={id(obj)}, pk={getattr(obj, 'pk', None)}) "
+                    f"missing upsert metadata - defaulting to 'created'. "
+                    f"This may indicate a bug in the upsert metadata tagging.",
+                )
+                was_created = True
+            else:
+                was_created = getattr(obj, "_bulk_hooks_was_created", True)
+            
+            if was_created:
+                created_objects.append(obj)
+            else:
+                updated_objects.append(obj)
+        
+        if missing_metadata_count > 0:
+            logger.error(
+                f"UPSERT METADATA BUG: {missing_metadata_count}/{len(result_objects)} objects "
+                f"missing metadata. This will cause incorrect hook firing!",
+            )
+        
+        logger.info(f"Upsert after hooks: {len(created_objects)} created, {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.43 → django_bulk_hooks-0.2.45}/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.43 → django_bulk_hooks-0.2.45}/pyproject.toml

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