django-bulk-hooks 0.2.12__tar.gz → 0.2.13__tar.gz

{django_bulk_hooks-0.2.12 → django_bulk_hooks-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.12
+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.12 → django_bulk_hooks-0.2.13}/django_bulk_hooks/operations/coordinator.py

@@ -214,29 +214,28 @@ class BulkOperationCoordinator:
         """
         Execute queryset update with hooks - optimized for performance.
         
-        ARCHITECTURE: Database-Level Update with AFTER-Only Hooks
-        ==========================================================
+        ARCHITECTURE: Database-Level Update with Hook Support
+        =======================================================
         
-        Uses native Django queryset.update() for maximum performance,
-        then fetches results and runs AFTER hooks.
+        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)
         
-        This approach:
-        - ✅ Uses native SQL UPDATE (fastest for aggregations, F(), Subquery)
-        - ✅ Maintains framework patterns (MTI support, changeset building)
-        - ✅ Runs AFTER_UPDATE hooks with old/new state
-        - ❌ BEFORE_UPDATE hooks cannot modify values (use bulk_update() instead)
+        Total DML: 1 (queryset.update) + 1 (bulk_update if hooks modify anything)
         
-        For cases where BEFORE hooks need to modify values, use bulk_update():
-        - MyModel.objects.bulk_update(objs, fields)  # Allows BEFORE modifications
-        - MyModel.objects.update(...)                 # Fast, AFTER hooks only
-
-        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
+        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)
+        
+        For true BEFORE semantics (prevent/modify before DB write), use bulk_update().
         """
         # Check bypass early
         from django_bulk_hooks.context import get_bypass_hooks
@@ -258,8 +257,8 @@ class BulkOperationCoordinator:
         """
         Execute queryset update with hooks - fast path using native Django update.
         
-        This method follows framework patterns but is optimized for database-level
-        operations where BEFORE hooks cannot modify values.
+        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
@@ -293,14 +292,74 @@ class BulkOperationCoordinator:
         
         # Mark that this is a queryset update (for potential hook inspection)
         changeset.operation_meta['is_queryset_update'] = True
-        changeset.operation_meta['allows_before_modifications'] = False
+        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. AFTER hooks only (following MTI pattern from _execute_with_mti_hooks)
+        # 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)

{django_bulk_hooks-0.2.12 → django_bulk_hooks-0.2.13}/pyproject.toml

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