django-bulk-hooks 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

django_bulk_hooks/dispatcher.py

@@ -1,246 +1,246 @@
-"""
-HookDispatcher: Single execution path for all hooks.
-
-Provides deterministic, priority-ordered hook execution,
-similar to Salesforce's hook framework.
-"""
-
-import logging
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-
-class HookDispatcher:
-    """
-    Single execution path for all hooks.
-
-    Responsibilities:
-    - Execute hooks in priority order
-    - Filter records based on conditions
-    - Provide ChangeSet context to hooks
-    - Fail-fast error propagation
-    - Manage complete operation lifecycle (VALIDATE, BEFORE, AFTER)
-    """
-
-    def __init__(self, registry):
-        """
-        Initialize the dispatcher.
-
-        Args:
-            registry: The hook registry (provides get_hooks method)
-        """
-        self.registry = registry
-
-    def execute_operation_with_hooks(
-        self,
-        changeset,
-        operation,
-        event_prefix,
-        bypass_hooks=False,
-        bypass_validation=False,
-    ):
-        """
-        Execute operation with full hook lifecycle.
-
-        This is the high-level method that coordinates the complete lifecycle:
-        1. VALIDATE_{event}
-        2. BEFORE_{event}
-        3. Actual operation
-        4. AFTER_{event}
-
-        Args:
-            changeset: ChangeSet for the operation
-            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
-        """
-        if bypass_hooks:
-            return operation()
-
-        # VALIDATE phase
-        if not bypass_validation:
-            self.dispatch(changeset, f"validate_{event_prefix}", bypass_hooks=False)
-
-        # BEFORE phase
-        self.dispatch(changeset, f"before_{event_prefix}", bypass_hooks=False)
-
-        # Execute the actual operation
-        result = operation()
-
-        # AFTER phase - use result if operation returns modified data
-        if result and isinstance(result, list) and event_prefix == "create":
-            # For create, rebuild changeset with assigned PKs
-            from django_bulk_hooks.helpers import build_changeset_for_create
-
-            changeset = build_changeset_for_create(changeset.model_cls, result)
-
-        self.dispatch(changeset, f"after_{event_prefix}", bypass_hooks=False)
-
-        return result
-
-    def dispatch(self, changeset, event, bypass_hooks=False):
-        """
-        Dispatch hooks for a changeset with deterministic ordering.
-
-        This is the single execution path for ALL hooks in the system.
-
-        Args:
-            changeset: ChangeSet instance with record changes
-            event: Event name (e.g., 'after_update', 'before_create')
-            bypass_hooks: If True, skip all hook execution
-
-        Raises:
-            Exception: Any exception raised by a hook (fails fast)
-            RecursionError: If hooks create an infinite loop (Python's built-in limit)
-        """
-        if bypass_hooks:
-            return
-
-        # Get hooks sorted by priority (deterministic order)
-        hooks = self.registry.get_hooks(changeset.model_cls, event)
-
-        if not hooks:
-            return
-
-        # Execute hooks in priority order
-        logger.info(f"🔥 HOOKS: Executing {len(hooks)} hooks for {changeset.model_cls.__name__}.{event}")
-        for handler_cls, method_name, condition, priority in hooks:
-            logger.info(f"  → {handler_cls.__name__}.{method_name} (priority={priority})")
-            self._execute_hook(handler_cls, method_name, condition, changeset)
-
-    def _execute_hook(self, handler_cls, method_name, condition, changeset):
-        """
-        Execute a single hook with condition checking.
-
-        Args:
-            handler_cls: The hook handler class
-            method_name: Name of the method to call
-            condition: Optional condition to filter records
-            changeset: ChangeSet with all record changes
-        """
-        # Filter records based on condition
-        if condition:
-            filtered_changes = [
-                change
-                for change in changeset.changes
-                if condition.check(change.new_record, change.old_record)
-            ]
-
-            if not filtered_changes:
-                # No records match condition, skip this hook
-                return
-
-            # Create filtered changeset
-            from django_bulk_hooks.changeset import ChangeSet
-
-            filtered_changeset = ChangeSet(
-                changeset.model_cls,
-                filtered_changes,
-                changeset.operation_type,
-                changeset.operation_meta,
-            )
-        else:
-            # No condition, use full changeset
-            filtered_changeset = changeset
-
-        # Use DI factory to create handler instance
-        from django_bulk_hooks.factory import create_hook_instance
-
-        handler = create_hook_instance(handler_cls)
-        method = getattr(handler, method_name)
-
-        # Check if method has @select_related decorator
-        preload_func = getattr(method, "_select_related_preload", None)
-        if preload_func:
-            # Preload relationships to prevent N+1 queries
-            try:
-                model_cls_override = getattr(handler, "model_cls", None)
-
-                # Get FK fields being updated to avoid preloading conflicting relationships
-                skip_fields = changeset.operation_meta.get('fk_fields_being_updated', set())
-
-                # Preload for new_records
-                if filtered_changeset.new_records:
-                    logger.debug(
-                        f"Preloading relationships for {len(filtered_changeset.new_records)} "
-                        f"new_records for {handler_cls.__name__}.{method_name}"
-                    )
-                    preload_func(
-                        filtered_changeset.new_records,
-                        model_cls=model_cls_override,
-                        skip_fields=skip_fields
-                    )
-
-                # Also preload for old_records (for conditions that check previous values)
-                if filtered_changeset.old_records:
-                    logger.debug(
-                        f"Preloading relationships for {len(filtered_changeset.old_records)} "
-                        f"old_records for {handler_cls.__name__}.{method_name}"
-                    )
-                    preload_func(
-                        filtered_changeset.old_records,
-                        model_cls=model_cls_override,
-                        skip_fields=skip_fields
-                    )
-            except Exception:
-                logger.debug(
-                    "select_related preload failed for %s.%s",
-                    handler_cls.__name__,
-                    method_name,
-                    exc_info=True,
-                )
-
-        # Execute hook with ChangeSet
-        # 
-        # ARCHITECTURE NOTE: Hook Contract
-        # ====================================
-        # All hooks must accept **kwargs for forward compatibility.
-        # We pass: changeset, new_records, old_records
-        # 
-        # Old hooks that don't use changeset: def hook(self, new_records, old_records, **kwargs)
-        # New hooks that do use changeset:    def hook(self, changeset, new_records, old_records, **kwargs)
-        # 
-        # This is standard Python framework design (see Django signals, Flask hooks, etc.)
-        logger.info(f"    🚀 Executing: {handler_cls.__name__}.{method_name}")
-        try:
-            method(
-                changeset=filtered_changeset,
-                new_records=filtered_changeset.new_records,
-                old_records=filtered_changeset.old_records,
-            )
-            logger.info(f"    ✅ Completed: {handler_cls.__name__}.{method_name}")
-        except Exception as e:
-            # Fail-fast: re-raise to rollback transaction
-            logger.error(
-                f"Hook {handler_cls.__name__}.{method_name} failed: {e}",
-                exc_info=True,
-            )
-            raise
-
-
-# Global dispatcher instance
-_dispatcher: Optional[HookDispatcher] = None
-
-
-def get_dispatcher():
-    """
-    Get the global dispatcher instance.
-
-    Creates the dispatcher on first access (singleton pattern).
-
-    Returns:
-        HookDispatcher instance
-    """
-    global _dispatcher
-    if _dispatcher is None:
-        # Import here to avoid circular dependency
-        from django_bulk_hooks.registry import get_registry
-
-        # Create dispatcher with the registry instance
-        _dispatcher = HookDispatcher(get_registry())
-    return _dispatcher
+"""
+HookDispatcher: Single execution path for all hooks.
+
+Provides deterministic, priority-ordered hook execution,
+similar to Salesforce's hook framework.
+"""
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class HookDispatcher:
+    """
+    Single execution path for all hooks.
+
+    Responsibilities:
+    - Execute hooks in priority order
+    - Filter records based on conditions
+    - Provide ChangeSet context to hooks
+    - Fail-fast error propagation
+    - Manage complete operation lifecycle (VALIDATE, BEFORE, AFTER)
+    """
+
+    def __init__(self, registry):
+        """
+        Initialize the dispatcher.
+
+        Args:
+            registry: The hook registry (provides get_hooks method)
+        """
+        self.registry = registry
+
+    def execute_operation_with_hooks(
+        self,
+        changeset,
+        operation,
+        event_prefix,
+        bypass_hooks=False,
+        bypass_validation=False,
+    ):
+        """
+        Execute operation with full hook lifecycle.
+
+        This is the high-level method that coordinates the complete lifecycle:
+        1. VALIDATE_{event}
+        2. BEFORE_{event}
+        3. Actual operation
+        4. AFTER_{event}
+
+        Args:
+            changeset: ChangeSet for the operation
+            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
+        """
+        if bypass_hooks:
+            return operation()
+
+        # VALIDATE phase
+        if not bypass_validation:
+            self.dispatch(changeset, f"validate_{event_prefix}", bypass_hooks=False)
+
+        # BEFORE phase
+        self.dispatch(changeset, f"before_{event_prefix}", bypass_hooks=False)
+
+        # Execute the actual operation
+        result = operation()
+
+        # AFTER phase - use result if operation returns modified data
+        if result and isinstance(result, list) and event_prefix == "create":
+            # For create, rebuild changeset with assigned PKs
+            from django_bulk_hooks.helpers import build_changeset_for_create
+
+            changeset = build_changeset_for_create(changeset.model_cls, result)
+
+        self.dispatch(changeset, f"after_{event_prefix}", bypass_hooks=False)
+
+        return result
+
+    def dispatch(self, changeset, event, bypass_hooks=False):
+        """
+        Dispatch hooks for a changeset with deterministic ordering.
+
+        This is the single execution path for ALL hooks in the system.
+
+        Args:
+            changeset: ChangeSet instance with record changes
+            event: Event name (e.g., 'after_update', 'before_create')
+            bypass_hooks: If True, skip all hook execution
+
+        Raises:
+            Exception: Any exception raised by a hook (fails fast)
+            RecursionError: If hooks create an infinite loop (Python's built-in limit)
+        """
+        if bypass_hooks:
+            return
+
+        # Get hooks sorted by priority (deterministic order)
+        hooks = self.registry.get_hooks(changeset.model_cls, event)
+
+        if not hooks:
+            return
+
+        # Execute hooks in priority order
+        logger.info(f"🔥 HOOKS: Executing {len(hooks)} hooks for {changeset.model_cls.__name__}.{event}")
+        for handler_cls, method_name, condition, priority in hooks:
+            logger.info(f"  → {handler_cls.__name__}.{method_name} (priority={priority})")
+            self._execute_hook(handler_cls, method_name, condition, changeset)
+
+    def _execute_hook(self, handler_cls, method_name, condition, changeset):
+        """
+        Execute a single hook with condition checking.
+
+        Args:
+            handler_cls: The hook handler class
+            method_name: Name of the method to call
+            condition: Optional condition to filter records
+            changeset: ChangeSet with all record changes
+        """
+        # Filter records based on condition
+        if condition:
+            filtered_changes = [
+                change
+                for change in changeset.changes
+                if condition.check(change.new_record, change.old_record)
+            ]
+
+            if not filtered_changes:
+                # No records match condition, skip this hook
+                return
+
+            # Create filtered changeset
+            from django_bulk_hooks.changeset import ChangeSet
+
+            filtered_changeset = ChangeSet(
+                changeset.model_cls,
+                filtered_changes,
+                changeset.operation_type,
+                changeset.operation_meta,
+            )
+        else:
+            # No condition, use full changeset
+            filtered_changeset = changeset
+
+        # Use DI factory to create handler instance
+        from django_bulk_hooks.factory import create_hook_instance
+
+        handler = create_hook_instance(handler_cls)
+        method = getattr(handler, method_name)
+
+        # Check if method has @select_related decorator
+        preload_func = getattr(method, "_select_related_preload", None)
+        if preload_func:
+            # Preload relationships to prevent N+1 queries
+            try:
+                model_cls_override = getattr(handler, "model_cls", None)
+
+                # Get FK fields being updated to avoid preloading conflicting relationships
+                skip_fields = changeset.operation_meta.get('fk_fields_being_updated', set())
+
+                # Preload for new_records
+                if filtered_changeset.new_records:
+                    logger.debug(
+                        f"Preloading relationships for {len(filtered_changeset.new_records)} "
+                        f"new_records for {handler_cls.__name__}.{method_name}"
+                    )
+                    preload_func(
+                        filtered_changeset.new_records,
+                        model_cls=model_cls_override,
+                        skip_fields=skip_fields
+                    )
+
+                # Also preload for old_records (for conditions that check previous values)
+                if filtered_changeset.old_records:
+                    logger.debug(
+                        f"Preloading relationships for {len(filtered_changeset.old_records)} "
+                        f"old_records for {handler_cls.__name__}.{method_name}"
+                    )
+                    preload_func(
+                        filtered_changeset.old_records,
+                        model_cls=model_cls_override,
+                        skip_fields=skip_fields
+                    )
+            except Exception:
+                logger.debug(
+                    "select_related preload failed for %s.%s",
+                    handler_cls.__name__,
+                    method_name,
+                    exc_info=True,
+                )
+
+        # Execute hook with ChangeSet
+        # 
+        # ARCHITECTURE NOTE: Hook Contract
+        # ====================================
+        # All hooks must accept **kwargs for forward compatibility.
+        # We pass: changeset, new_records, old_records
+        # 
+        # Old hooks that don't use changeset: def hook(self, new_records, old_records, **kwargs)
+        # New hooks that do use changeset:    def hook(self, changeset, new_records, old_records, **kwargs)
+        # 
+        # This is standard Python framework design (see Django signals, Flask hooks, etc.)
+        logger.info(f"    🚀 Executing: {handler_cls.__name__}.{method_name}")
+        try:
+            method(
+                changeset=filtered_changeset,
+                new_records=filtered_changeset.new_records,
+                old_records=filtered_changeset.old_records,
+            )
+            logger.info(f"    ✅ Completed: {handler_cls.__name__}.{method_name}")
+        except Exception as e:
+            # Fail-fast: re-raise to rollback transaction
+            logger.error(
+                f"Hook {handler_cls.__name__}.{method_name} failed: {e}",
+                exc_info=True,
+            )
+            raise
+
+
+# Global dispatcher instance
+_dispatcher: Optional[HookDispatcher] = None
+
+
+def get_dispatcher():
+    """
+    Get the global dispatcher instance.
+
+    Creates the dispatcher on first access (singleton pattern).
+
+    Returns:
+        HookDispatcher instance
+    """
+    global _dispatcher
+    if _dispatcher is None:
+        # Import here to avoid circular dependency
+        from django_bulk_hooks.registry import get_registry
+
+        # Create dispatcher with the registry instance
+        _dispatcher = HookDispatcher(get_registry())
+    return _dispatcher

django_bulk_hooks/operations/coordinator.py

@@ -212,114 +212,158 @@ class BulkOperationCoordinator:
         self, update_kwargs, bypass_hooks=False, bypass_validation=False
     ):
         """
-        Execute queryset update with hooks.
+        Execute queryset update with hooks - optimized for performance.
         
-        ARCHITECTURE: Application-Layer Update with Expression Resolution
-        ===================================================================
+        ARCHITECTURE: Database-Level Update with Hook Support
+        =======================================================
         
-        When hooks are enabled, queryset.update() is transformed into bulk_update()
-        to allow BEFORE hooks to modify records. This is a deliberate design choice:
+        For queryset.update() operations:
+        1. Fetch old state (before DB update)
+        2. Execute native Django UPDATE (fast, direct SQL with Subquery/F() support)
+        3. Fetch new state (after DB update, with computed values)
+        4. Run BEFORE_UPDATE hooks with old/new state
+           - Hooks can see Subquery-computed values via new_records
+           - Hooks CAN modify instances (e.g., set derived fields)
+           - Modifications are auto-persisted with bulk_update
+        5. Run AFTER_UPDATE hooks (for read-only side effects)
         
-        1. Fetch instances from the queryset (we need them for hooks anyway)
-        2. Resolve SQL expressions (F(), Subquery, Case, etc.) to concrete values
-        3. Apply resolved values to instances
-        4. Run BEFORE hooks (which can now modify the instances)
-        5. Use bulk_update() to persist the (possibly modified) instances
-        6. Run AFTER hooks with final state
+        Total DML: 1 (queryset.update) + 1 (bulk_update if hooks modify anything)
         
-        This approach:
-        - ✅ Allows BEFORE hooks to modify values (feature request)
-        - ✅ Preserves SQL expression semantics (materializes them correctly)
-        - ✅ Eliminates the double-fetch (was fetching before AND after)
-        - ✅ More efficient than previous implementation
-        - ✅ Maintains Salesforce-like hook contract
+        Note: BEFORE_UPDATE runs AFTER the primary database update.
+        This enables:
+        - HasChanged conditions to work with Subquery-computed values
+        - Cascading updates from hook modifications
+        - Optimal performance (Subquery stays in SQL)
         
-        SQL expressions are resolved per-instance using Django's annotate(),
-        which ensures correct evaluation of:
-        - F() expressions: F('balance') + 100
-        - Subquery: Subquery(related.aggregate(...))
-        - Case/When: Case(When(...))
-        - Database functions: Upper(), Concat(), etc.
-        - Any other Django Expression
+        For true BEFORE semantics (prevent/modify before DB write), use bulk_update().
+        """
+        # Check bypass early
+        from django_bulk_hooks.context import get_bypass_hooks
+        should_bypass = bypass_hooks or get_bypass_hooks()
         
-        Trade-off:
-        - Uses bulk_update() internally (slightly different SQL than queryset.update)
-        - Expression resolution may add overhead for complex expressions
-        - But eliminates the refetch, so overall more efficient
+        if should_bypass:
+            # No hooks - use original queryset.update() for max performance
+            return BaseQuerySet.update(self.queryset, **update_kwargs)
+
+        # Delegate to specialized queryset update handler
+        return self._execute_queryset_update_with_hooks(
+            update_kwargs=update_kwargs,
+            bypass_validation=bypass_validation,
+        )
 
+    def _execute_queryset_update_with_hooks(
+        self, update_kwargs, bypass_validation=False
+    ):
+        """
+        Execute queryset update with hooks - fast path using native Django update.
+        
+        This method provides full hook lifecycle support for queryset.update()
+        including BEFORE_UPDATE hooks with automatic persistence of modifications.
+        
         Args:
             update_kwargs: Dict of fields to update
-            bypass_hooks: Skip all hooks if True
             bypass_validation: Skip validation hooks if True
-
+            
         Returns:
             Number of objects updated
         """
-        # Fetch instances from queryset
-        instances = list(self.queryset)
-        if not instances:
+        # 1. Fetch old state (before DB update)
+        old_instances = list(self.queryset)
+        if not old_instances:
             return 0
-
-        # Check both parameter and context for bypass_hooks
-        from django_bulk_hooks.context import get_bypass_hooks
-        should_bypass = bypass_hooks or get_bypass_hooks()
+        old_records_map = {inst.pk: inst for inst in old_instances}
         
-        if should_bypass:
-            # No hooks - use original queryset.update() for max performance
-            return BaseQuerySet.update(self.queryset, **update_kwargs)
-
-        # Resolve expressions and apply to instances
-        # Delegate to analyzer for expression resolution and value application
-        fields_to_update = self.analyzer.apply_update_values(instances, update_kwargs)
+        # 2. Execute native Django update (FAST)
+        result = BaseQuerySet.update(self.queryset, **update_kwargs)
         
-        # Now instances have the resolved values applied
-        # Fetch old records for comparison (single bulk query)
-        old_records_map = self.analyzer.fetch_old_records_map(instances)
-
-        # Detect FK fields being updated to prevent @select_related conflicts
-        fk_fields_being_updated = self._get_fk_fields_being_updated(update_kwargs)
-
-        # Build changeset for VALIDATE and BEFORE hooks
-        # instances now have the "intended" values from update_kwargs
+        if result == 0:
+            return 0
+        
+        # 3. Fetch new state (after DB update)
+        new_instances = list(self.queryset)
+        
+        # 4. Build changeset (using framework helper)
         changeset = build_changeset_for_update(
             self.model_cls,
-            instances,
+            new_instances,
             update_kwargs,
             old_records_map=old_records_map,
         )
-
-        # Add FK field info to changeset meta for dispatcher to use
-        if fk_fields_being_updated:
-            changeset.operation_meta['fk_fields_being_updated'] = fk_fields_being_updated
-
-        # Execute VALIDATE and BEFORE hooks
-        # Hooks can now modify the instances and changes will persist
-        if not bypass_validation:
-            self.dispatcher.dispatch(changeset, "validate_update", bypass_hooks=False)
-        self.dispatcher.dispatch(changeset, "before_update", bypass_hooks=False)
-
-        # COORDINATION LOGIC: Determine all fields to persist
-        # Hooks may have modified fields beyond the original update_kwargs.
-        # We need to detect those changes and include them in bulk_update.
-        # This is coordination between: hooks → field detection → executor
-        additional_changed_fields = self.analyzer.detect_changed_fields(instances)
-        all_fields_to_update = list(set(fields_to_update) | set(additional_changed_fields))
         
-        # Use bulk_update with all modified fields (original + hook modifications)
-        result = self.executor.bulk_update(instances, all_fields_to_update, batch_size=None)
-
-        # Build changeset for AFTER hooks
-        # No refetch needed! instances already have final state from bulk_update
-        changeset_after = build_changeset_for_update(
-            self.model_cls,
-            instances,
-            update_kwargs,
-            old_records_map=old_records_map,
-        )
-
-        # Execute AFTER hooks with final state
-        self.dispatcher.dispatch(changeset_after, "after_update", bypass_hooks=False)
-
+        # Mark that this is a queryset update (for potential hook inspection)
+        changeset.operation_meta['is_queryset_update'] = True
+        changeset.operation_meta['allows_before_modifications'] = True
+        
+        # 5. Get MTI chain (follow framework pattern)
+        models_in_chain = [self.model_cls]
+        if self.mti_handler.is_mti_model():
+            models_in_chain.extend(self.mti_handler.get_parent_models())
+        
+        # 6. BEFORE_UPDATE hooks (with auto-persistence)
+        # Snapshot state before hooks
+        pre_hook_state = {}
+        for instance in new_instances:
+            if instance.pk is not None:
+                pre_hook_values = {}
+                for field in self.model_cls._meta.fields:
+                    try:
+                        pre_hook_values[field.name] = getattr(instance, field.name, None)
+                    except Exception:
+                        pre_hook_values[field.name] = None
+                pre_hook_state[instance.pk] = pre_hook_values
+        
+        # Dispatch 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)
+        
+        # Detect modifications made by BEFORE_UPDATE hooks
+        hook_modified_fields = set()
+        for instance in new_instances:
+            if instance.pk in pre_hook_state:
+                for field_name, pre_value in pre_hook_state[instance.pk].items():
+                    try:
+                        current_value = getattr(instance, field_name, None)
+                    except Exception:
+                        current_value = None
+                    
+                    if current_value != pre_value:
+                        hook_modified_fields.add(field_name)
+        
+        # Auto-persist hook modifications
+        if hook_modified_fields:
+            logger.info(
+                f"BEFORE_UPDATE hooks modified {len(hook_modified_fields)} fields: {hook_modified_fields}"
+            )
+            logger.info("Auto-persisting modifications with bulk_update")
+            
+            # Use bulk_update to persist changes
+            # This will trigger another hook cycle (Salesforce-style cascading)
+            from django.db.models import QuerySet as BaseQuerySet
+            base_qs = BaseQuerySet(model=self.model_cls, using=self.queryset.db)
+            base_qs.bulk_update(new_instances, list(hook_modified_fields))
+            
+            # Refresh instances after bulk_update to reflect any changes
+            refreshed_map = {
+                inst.pk: inst 
+                for inst in self.model_cls.objects.filter(
+                    pk__in=[obj.pk for obj in new_instances]
+                )
+            }
+            for instance in new_instances:
+                if instance.pk in refreshed_map:
+                    refreshed = refreshed_map[instance.pk]
+                    for field in self.model_cls._meta.fields:
+                        try:
+                            setattr(instance, field.name, getattr(refreshed, field.name))
+                        except Exception:
+                            pass
+        
+        # 7. 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)
+        
         return result
 
     @transaction.atomic

{django_bulk_hooks-0.2.11.dist-info → django_bulk_hooks-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.11
+Version: 0.2.13
 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.11.dist-info → django_bulk_hooks-0.2.13.dist-info}/RECORD

@@ -4,7 +4,7 @@ django_bulk_hooks/conditions.py,sha256=qtGjToKXC8FPUPK31Mib-GMzc9GSdrH90M2pT3CIs
 django_bulk_hooks/constants.py,sha256=PxpEETaO6gdENcTPoXS586lerGKVP3nmjpDvOkmhYxI,509
 django_bulk_hooks/context.py,sha256=mqaC5-yESDTA5ruI7fuXlt8qSgKuOFp0mjq7h1-4HdQ,1926
 django_bulk_hooks/decorators.py,sha256=hc8MSG5XXEiT5kgsf4Opzpj8jAb-OYqcvssuZxCIncQ,11894
-django_bulk_hooks/dispatcher.py,sha256=k3ndhY8e2N2nIHn22hFrCsDd3U5RVbPQtQ6Xf9E8UQE,8923
+django_bulk_hooks/dispatcher.py,sha256=-aXu3hiVHvEqLU2jFHLXy8idMtVWRtkgMCRKtsw48sI,8677
 django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
 django_bulk_hooks/factory.py,sha256=JmjQiJPfAnytXrO6r6qOadX5yX0-sfpbZ9V8nwX3MAg,20013
 django_bulk_hooks/handler.py,sha256=2-k0GPWGSQ6acfvV0qJgDH8aa0z51DqdpX5vSJ6Uawk,4759
@@ -14,12 +14,12 @@ django_bulk_hooks/models.py,sha256=62tn5wL55EjJVOsZofMluhEJB8bH7CzBvH0vd214_RY,2
 django_bulk_hooks/operations/__init__.py,sha256=5L5NnwiFw8Yn5WO6-38eGdCYBkA0URpwyDcAdeYfc5w,550
 django_bulk_hooks/operations/analyzer.py,sha256=s6FM53ho1raPdKU-VjjW0SWymXyrJe0I_Wu8XsXFdSY,9065
 django_bulk_hooks/operations/bulk_executor.py,sha256=7VJgeTFcMQ9ZELvCV6WR6udUPJNL6Kf-w9iEva6pIPA,18271
-django_bulk_hooks/operations/coordinator.py,sha256=tCQA0yfnt1bh8hLR_g_WlZc2tRpnWDbTb9aWKaAfWmo,18174
+django_bulk_hooks/operations/coordinator.py,sha256=Qt6BHROXdMuI9v7s4oAB3DD2gE-jkKV4u52rLRjtR-M,19844
 django_bulk_hooks/operations/mti_handler.py,sha256=eIH-tImMqcWR5lLQr6Ca-HeVYta-UkXk5X5fcpS885Y,18245
 django_bulk_hooks/operations/mti_plans.py,sha256=fHUYbrUAHq8UXqxgAD43oHdTxOnEkmpxoOD4Qrzfqk8,2878
 django_bulk_hooks/queryset.py,sha256=ody4MXrRREL27Ts2ey1UpS0tb5Dxnw-6kN3unxPQ3zY,5860
 django_bulk_hooks/registry.py,sha256=UPerNhtVz_9tKZqrYSZD2LhjAcs4F6hVUuk8L5oOeHc,8821
-django_bulk_hooks-0.2.11.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.2.11.dist-info/METADATA,sha256=XjBb-_Q9gbnDEim8E7qQ4MY-iUUourgH8nNEkdFvHCI,9265
-django_bulk_hooks-0.2.11.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.2.11.dist-info/RECORD,,
+django_bulk_hooks-0.2.13.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.2.13.dist-info/METADATA,sha256=TTS7G8eL1PN82da4t5u0_EBBE3tG2sfhr1wNVtKZ43s,9265
+django_bulk_hooks-0.2.13.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.2.13.dist-info/RECORD,,