django-bulk-hooks 0.2.2__tar.gz → 0.2.3__tar.gz

{django_bulk_hooks-0.2.2 → django_bulk_hooks-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.2
+Version: 0.2.3
 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.2 → django_bulk_hooks-0.2.3}/django_bulk_hooks/operations/analyzer.py

@@ -206,3 +206,72 @@ class ModelAnalyzer:
 
         # Return as sorted list for deterministic behavior
         return sorted(changed_fields_set)
+
+    def resolve_expression(self, field_name, expression, instance):
+        """
+        Resolve a SQL expression to a concrete value for a specific instance.
+        
+        This method materializes database expressions (F(), Subquery, Case, etc.)
+        into concrete values by using Django's annotate() mechanism.
+        
+        Args:
+            field_name: Name of the field being updated
+            expression: The expression or value to resolve
+            instance: The model instance to resolve for
+            
+        Returns:
+            The resolved concrete value
+        """
+        from django.db.models import Expression
+        from django.db.models.expressions import Combinable
+        
+        # Simple value - return as-is
+        if not isinstance(expression, (Expression, Combinable)):
+            return expression
+        
+        # For complex expressions, evaluate them in database context
+        # Use annotate() which Django properly handles for all expression types
+        try:
+            # Create a queryset for just this instance
+            instance_qs = self.model_cls.objects.filter(pk=instance.pk)
+            
+            # Use annotate with the expression and let Django resolve it
+            resolved_value = instance_qs.annotate(
+                _resolved_value=expression
+            ).values_list('_resolved_value', flat=True).first()
+            
+            return resolved_value
+        except Exception as e:
+            # If expression resolution fails, log and return original
+            logger.warning(
+                f"Failed to resolve expression for field '{field_name}' "
+                f"on {self.model_cls.__name__}: {e}. Using original value."
+            )
+            return expression
+
+    def apply_update_values(self, instances, update_kwargs):
+        """
+        Apply update_kwargs to instances, resolving any SQL expressions.
+        
+        This method transforms queryset.update()-style kwargs (which may contain
+        F() expressions, Subquery, Case, etc.) into concrete values and applies
+        them to the instances.
+        
+        Args:
+            instances: List of model instances to update
+            update_kwargs: Dict of {field_name: value_or_expression}
+            
+        Returns:
+            List of field names that were updated
+        """
+        if not instances or not update_kwargs:
+            return []
+        
+        fields_updated = list(update_kwargs.keys())
+        
+        for field_name, value in update_kwargs.items():
+            for instance in instances:
+                resolved_value = self.resolve_expression(field_name, value, instance)
+                setattr(instance, field_name, resolved_value)
+        
+        return fields_updated

{django_bulk_hooks-0.2.2 → django_bulk_hooks-0.2.3}/django_bulk_hooks/operations/coordinator.py

@@ -214,32 +214,38 @@ class BulkOperationCoordinator:
         """
         Execute queryset update with hooks.
         
-        ARCHITECTURE: Database-Layer vs Application-Layer Updates
-        ==========================================================
+        ARCHITECTURE: Application-Layer Update with Expression Resolution
+        ===================================================================
         
-        Unlike bulk_update(objs), queryset.update() is a pure SQL UPDATE operation.
-        The database evaluates ALL expressions (F(), Subquery, Case, functions, etc.)
-        without Python ever seeing the new values.
+        When hooks are enabled, queryset.update() is transformed into bulk_update()
+        to allow BEFORE hooks to modify records. This is a deliberate design choice:
         
-        To maintain Salesforce's hook contract (AFTER hooks see accurate new_records),
-        we ALWAYS refetch instances after the update for AFTER hooks.
+        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
         
-        This is NOT a hack - it respects the fundamental architectural difference:
+        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
         
-        1. queryset.update():  Database evaluates → Must refetch for AFTER hooks
-        2. bulk_update(objs):  Python has values → No refetch needed
-        
-        The refetch handles ALL database-level changes:
-        - F() expressions: F('count') + 1
+        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(status='A', then=Value('Active')))
-        - Database functions: Upper('name'), Concat(...)
-        - Database hooks/defaults
-        - Any other DB-evaluated expression
+        - Case/When: Case(When(...))
+        - Database functions: Upper(), Concat(), etc.
+        - Any other Django Expression
         
         Trade-off:
-        - Cost: 1 extra SELECT query per queryset.update() call
-        - Benefit: 100% correctness for ALL database expressions
+        - 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
 
         Args:
             update_kwargs: Dict of fields to update
@@ -249,52 +255,56 @@ class BulkOperationCoordinator:
         Returns:
             Number of objects updated
         """
-        # Fetch instances BEFORE update
+        # Fetch instances from queryset
         instances = list(self.queryset)
         if not 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()
+        
+        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)
+        
+        # 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)
 
         # Build changeset for VALIDATE and BEFORE hooks
-        # These see pre-update state, which is correct
-        changeset_before = build_changeset_for_update(
+        # instances now have the "intended" values from update_kwargs
+        changeset = build_changeset_for_update(
             self.model_cls,
             instances,
             update_kwargs,
             old_records_map=old_records_map,
         )
 
-        if bypass_hooks:
-            # No hooks - just execute the update
-            return BaseQuerySet.update(self.queryset, **update_kwargs)
-
         # Execute VALIDATE and BEFORE hooks
+        # Hooks can now modify the instances and changes will persist
         if not bypass_validation:
-            self.dispatcher.dispatch(changeset_before, "validate_update", bypass_hooks=False)
-        self.dispatcher.dispatch(changeset_before, "before_update", bypass_hooks=False)
-
-        # Execute the actual database UPDATE
-        # Database evaluates all expressions here (Subquery, F(), etc.)
-        result = BaseQuerySet.update(self.queryset, **update_kwargs)
-
-        # Refetch instances to get actual post-update values from database
-        # This ensures AFTER hooks see the real final state
-        pks = [obj.pk for obj in instances]
-        refetched_instances = list(
-            self.model_cls.objects.filter(pk__in=pks)
-        )
+            self.dispatcher.dispatch(changeset, "validate_update", bypass_hooks=False)
+        self.dispatcher.dispatch(changeset, "before_update", bypass_hooks=False)
+
+        # Use bulk_update with the (possibly modified) instances
+        # This persists any modifications made by BEFORE hooks
+        result = self.executor.bulk_update(instances, fields_to_update, batch_size=None)
 
-        # Build changeset for AFTER hooks with accurate new values
+        # 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,
-            refetched_instances,  # Fresh from database
+            instances,
             update_kwargs,
-            old_records_map=old_records_map,  # Still have old values for comparison
+            old_records_map=old_records_map,
         )
 
-        # Execute AFTER hooks with accurate new_records
+        # Execute AFTER hooks with final state
         self.dispatcher.dispatch(changeset_after, "after_update", bypass_hooks=False)
 
         return result

{django_bulk_hooks-0.2.2 → django_bulk_hooks-0.2.3}/pyproject.toml

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