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

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

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

@@ -540,8 +540,21 @@ class BulkExecutor:
             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.44 → 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.
@@ -137,13 +136,10 @@ class BulkOperationCoordinator:
         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"
-            )
+            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(
@@ -236,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)
@@ -252,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).
         """
@@ -291,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
         """
@@ -387,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
         """
@@ -413,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}
         """
@@ -446,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
         """
@@ -477,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")
 
@@ -569,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
         """
@@ -600,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
         """
@@ -649,8 +649,9 @@ class BulkOperationCoordinator:
             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)
@@ -680,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)
@@ -697,27 +700,27 @@ class BulkOperationCoordinator:
     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')
+        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
@@ -725,57 +728,75 @@ class BulkOperationCoordinator:
         # Split objects by operation type
         created_objects = []
         updated_objects = []
+        missing_metadata_count = 0
         
         for obj in result_objects:
-            was_created = getattr(obj, '_bulk_hooks_was_created', True)
+            # 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)
         
-        logger.info(
-            f"Upsert after hooks: {len(created_objects)} created, "
-            f"{len(updated_objects)} updated"
-        )
+        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')
+            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.44 → django_bulk_hooks-0.2.45}/pyproject.toml

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