django-bulk-hooks 0.2.15__py3-none-any.whl → 0.2.17__py3-none-any.whl

django_bulk_hooks/operations/coordinator.py

@@ -6,15 +6,14 @@ a clean, simple API for the QuerySet to use.
 """
 
 import logging
+
+from django.core.exceptions import FieldDoesNotExist
 from django.db import transaction
 from django.db.models import QuerySet
-from django.core.exceptions import FieldDoesNotExist
 
-from django_bulk_hooks.helpers import (
-    build_changeset_for_create,
-    build_changeset_for_update,
-    build_changeset_for_delete,
-)
+from django_bulk_hooks.helpers import build_changeset_for_create
+from django_bulk_hooks.helpers import build_changeset_for_delete
+from django_bulk_hooks.helpers import build_changeset_for_update
 
 logger = logging.getLogger(__name__)
 
@@ -44,6 +43,7 @@ class BulkOperationCoordinator:
         # Lazy initialization
         self._analyzer = None
         self._mti_handler = None
+        self._record_classifier = None
         self._executor = None
         self._dispatcher = None
 
@@ -65,6 +65,15 @@ class BulkOperationCoordinator:
             self._mti_handler = MTIHandler(self.model_cls)
         return self._mti_handler
 
+    @property
+    def record_classifier(self):
+        """Get or create RecordClassifier"""
+        if self._record_classifier is None:
+            from django_bulk_hooks.operations.record_classifier import RecordClassifier
+
+            self._record_classifier = RecordClassifier(self.model_cls)
+        return self._record_classifier
+
     @property
     def executor(self):
         """Get or create BulkExecutor"""
@@ -75,6 +84,7 @@ class BulkOperationCoordinator:
                 queryset=self.queryset,
                 analyzer=self.analyzer,
                 mti_handler=self.mti_handler,
+                record_classifier=self.record_classifier,
             )
         return self._executor
 
@@ -185,7 +195,8 @@ class BulkOperationCoordinator:
         old_records_map = self.analyzer.fetch_old_records_map(objs)
 
         # Build changeset
-        from django_bulk_hooks.changeset import ChangeSet, RecordChange
+        from django_bulk_hooks.changeset import ChangeSet
+        from django_bulk_hooks.changeset import RecordChange
 
         changes = [
             RecordChange(
@@ -211,7 +222,7 @@ 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.
@@ -254,7 +265,7 @@ class BulkOperationCoordinator:
         or use bulk_update() directly (which has true before semantics).
         """
         from django_bulk_hooks.context import get_bypass_hooks
-        
+
         # Fast path: no hooks at all
         if bypass_hooks or get_bypass_hooks():
             return QuerySet.update(self.queryset, **update_kwargs)
@@ -266,7 +277,7 @@ 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.
@@ -286,20 +297,22 @@ class BulkOperationCoordinator:
         old_instances = list(self.queryset)
         if not old_instances:
             return 0
-            
+
         old_records_map = {inst.pk: inst for inst in old_instances}
-        
+
         # Step 2: Execute native Django update
         # Use stored reference to parent class method - clean and simple
         update_count = QuerySet.update(self.queryset, **update_kwargs)
-        
+
         if update_count == 0:
             return 0
-        
+
         # Step 3: Fetch new state (after database update)
         # This captures any Subquery/F() computed values
-        new_instances = list(self.queryset)
-        
+        # Use primary keys to fetch updated instances since queryset filters may no longer match
+        pks = [inst.pk for inst in old_instances]
+        new_instances = list(self.model_cls.objects.filter(pk__in=pks))
+
         # Step 4: Build changeset
         changeset = build_changeset_for_update(
             self.model_cls,
@@ -307,46 +320,54 @@ class BulkOperationCoordinator:
             update_kwargs,
             old_records_map=old_records_map,
         )
-        
+
         # Mark as queryset update for potential hook inspection
-        changeset.operation_meta['is_queryset_update'] = True
-        changeset.operation_meta['allows_modifications'] = True
-        
+        changeset.operation_meta["is_queryset_update"] = True
+        changeset.operation_meta["allows_modifications"] = True
+
         # Step 5: Get MTI inheritance chain
         models_in_chain = [self.model_cls]
         if self.mti_handler.is_mti_model():
             models_in_chain.extend(self.mti_handler.get_parent_models())
-        
+
         # Step 6: Run VALIDATE hooks (if not bypassed)
         if not bypass_validation:
             for model_cls in models_in_chain:
                 model_changeset = self._build_changeset_for_model(changeset, model_cls)
                 self.dispatcher.dispatch(
-                    model_changeset, 
-                    "validate_update", 
-                    bypass_hooks=False
+                    model_changeset,
+                    "validate_update",
+                    bypass_hooks=False,
                 )
-        
+
         # Step 7: Run BEFORE_UPDATE hooks with modification tracking
         modified_fields = self._run_before_update_hooks_with_tracking(
-            new_instances, 
-            models_in_chain, 
-            changeset
+            new_instances,
+            models_in_chain,
+            changeset,
         )
-        
+
         # Step 8: Auto-persist BEFORE_UPDATE modifications
         if modified_fields:
             self._persist_hook_modifications(new_instances, modified_fields)
-        
-        # Step 9: Run AFTER_UPDATE hooks (read-only side effects)
+
+        # Step 9: Take snapshot before AFTER_UPDATE hooks
+        pre_after_hook_state = self._snapshot_instance_state(new_instances)
+
+        # Step 10: Run AFTER_UPDATE hooks (read-only side effects)
         for model_cls in models_in_chain:
             model_changeset = self._build_changeset_for_model(changeset, model_cls)
             self.dispatcher.dispatch(
-                model_changeset, 
-                "after_update", 
-                bypass_hooks=False
+                model_changeset,
+                "after_update",
+                bypass_hooks=False,
             )
-        
+
+        # Step 11: Auto-persist AFTER_UPDATE modifications (if any)
+        after_modified_fields = self._detect_modifications(new_instances, pre_after_hook_state)
+        if after_modified_fields:
+            self._persist_hook_modifications(new_instances, after_modified_fields)
+
         return update_count
 
     def _run_before_update_hooks_with_tracking(self, instances, models_in_chain, changeset):
@@ -362,16 +383,16 @@ class BulkOperationCoordinator:
         """
         # Snapshot current state
         pre_hook_state = self._snapshot_instance_state(instances)
-        
+
         # Run BEFORE_UPDATE hooks
         for model_cls in models_in_chain:
             model_changeset = self._build_changeset_for_model(changeset, model_cls)
             self.dispatcher.dispatch(
-                model_changeset, 
-                "before_update", 
-                bypass_hooks=False
+                model_changeset,
+                "before_update",
+                bypass_hooks=False,
             )
-        
+
         # Detect modifications
         return self._detect_modifications(instances, pre_hook_state)
 
@@ -386,26 +407,26 @@ class BulkOperationCoordinator:
             Dict mapping pk -> {field_name: value}
         """
         snapshot = {}
-        
+
         for instance in instances:
             if instance.pk is None:
                 continue
-                
+
             field_values = {}
             for field in self.model_cls._meta.get_fields():
                 # Skip relations that aren't concrete fields
                 if field.many_to_many or field.one_to_many:
                     continue
-                    
+
                 field_name = field.name
                 try:
                     field_values[field_name] = getattr(instance, field_name)
                 except (AttributeError, FieldDoesNotExist):
                     # Field not accessible (e.g., deferred field)
                     field_values[field_name] = None
-                    
+
             snapshot[instance.pk] = field_values
-            
+
         return snapshot
 
     def _detect_modifications(self, instances, pre_hook_state):
@@ -420,23 +441,23 @@ class BulkOperationCoordinator:
             Set of field names that were modified
         """
         modified_fields = set()
-        
+
         for instance in instances:
             if instance.pk not in pre_hook_state:
                 continue
-                
+
             old_values = pre_hook_state[instance.pk]
-            
+
             for field_name, old_value in old_values.items():
                 try:
                     current_value = getattr(instance, field_name)
                 except (AttributeError, FieldDoesNotExist):
                     current_value = None
-                
+
                 # Compare values
                 if current_value != old_value:
                     modified_fields.add(field_name)
-        
+
         return modified_fields
 
     def _persist_hook_modifications(self, instances, modified_fields):
@@ -451,10 +472,10 @@ class BulkOperationCoordinator:
         """
         logger.info(
             f"Hooks modified {len(modified_fields)} field(s): "
-            f"{', '.join(sorted(modified_fields))}"
+            f"{', '.join(sorted(modified_fields))}",
         )
         logger.info("Auto-persisting modifications via bulk_update")
-        
+
         # Use Django's bulk_update directly (not our hook version)
         # Create a fresh QuerySet to avoid recursion
         fresh_qs = QuerySet(model=self.model_cls, using=self.queryset.db)
@@ -546,7 +567,7 @@ class BulkOperationCoordinator:
             ChangeSet for the target model
         """
         from django_bulk_hooks.changeset import ChangeSet
-        
+
         # Create new changeset with target model but same record changes
         return ChangeSet(
             model_cls=target_model_cls,
@@ -556,12 +577,12 @@ class BulkOperationCoordinator:
         )
 
     def _execute_with_mti_hooks(
-        self, 
-        changeset, 
-        operation, 
-        event_prefix, 
-        bypass_hooks=False, 
-        bypass_validation=False
+        self,
+        changeset,
+        operation,
+        event_prefix,
+        bypass_hooks=False,
+        bypass_validation=False,
     ):
         """
         Execute operation with hooks for entire MTI inheritance chain.
@@ -637,7 +658,7 @@ class BulkOperationCoordinator:
                 if (field.is_relation and
                     not field.many_to_many and
                     not field.one_to_many and
-                    hasattr(field, 'attname') 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
@@ -646,4 +667,4 @@ class BulkOperationCoordinator:
                 # If field lookup fails, skip it
                 continue
 
-        return fk_relationships
+        return fk_relationships