django-bulk-hooks 0.1.234__py3-none-any.whl → 0.1.236__py3-none-any.whl

django_bulk_hooks/context.py

@@ -22,6 +22,22 @@ def get_bypass_hooks():
     return getattr(_hook_context, 'bypass_hooks', False)
 
 
+# Thread-local storage for passing per-object field values from bulk_update -> update
+def set_bulk_update_value_map(value_map):
+    """Store a mapping of {pk: {field_name: value}} for the current thread.
+
+    This allows the internal update() call (triggered by Django's bulk_update)
+    to populate in-memory instances with the concrete values that will be
+    written to the database, instead of Django expression objects like Case/Cast.
+    """
+    _hook_context.bulk_update_value_map = value_map
+
+
+def get_bulk_update_value_map():
+    """Retrieve the mapping {pk: {field_name: value}} for the current thread, if any."""
+    return getattr(_hook_context, 'bulk_update_value_map', None)
+
+
 class HookContext:
     def __init__(self, model, bypass_hooks=False):
         self.model = model

django_bulk_hooks/queryset.py

@@ -1,11 +1,10 @@
 import logging
-from typing import Any
-
 from django.db import models, transaction
-from django.db.models import AutoField, Case, Value, When
-from django.db.models.functions import Cast
+from django.db.models import AutoField, Case, Field, Value, When
 
 from django_bulk_hooks import engine
+
+logger = logging.getLogger(__name__)
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -18,8 +17,10 @@ from django_bulk_hooks.constants import (
     VALIDATE_UPDATE,
 )
 from django_bulk_hooks.context import HookContext
-
-logger = logging.getLogger(__name__)
+from django_bulk_hooks.context import (
+    get_bulk_update_value_map,
+    set_bulk_update_value_map,
+)
 
 
 class HookQuerySetMixin:
@@ -29,7 +30,7 @@ class HookQuerySetMixin:
     """
 
     @transaction.atomic
-    def delete(self) -> int:
+    def delete(self):
         objs = list(self)
         if not objs:
             return 0
@@ -37,18 +38,22 @@ class HookQuerySetMixin:
         model_cls = self.model
         ctx = HookContext(model_cls)
 
+        # Run validation hooks first
         engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
 
+        # Then run business logic hooks
         engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
 
+        # Use Django's standard delete() method
         result = super().delete()
 
+        # Run AFTER_DELETE hooks
         engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
 
         return result
 
     @transaction.atomic
-    def update(self, **kwargs) -> int:
+    def update(self, **kwargs):
         instances = list(self)
         if not instances:
             return 0
@@ -63,19 +68,27 @@ class HookQuerySetMixin:
         }
         originals = [original_map.get(obj.pk) for obj in instances]
 
-        # Resolve subqueries to actual values before applying to instances
-        resolved_kwargs = self._resolve_subquery_values(kwargs)
+        # Check if any of the update values are Subquery objects
+        has_subquery = any(
+            hasattr(value, "query") and hasattr(value, "resolve_expression")
+            for value in kwargs.values()
+        )
 
-        # Apply resolved field updates to instances
+        # Apply field updates to instances
+        # If a per-object value map exists (from bulk_update), prefer it over kwargs
+        per_object_values = get_bulk_update_value_map()
         for obj in instances:
-            for field, value in resolved_kwargs.items():
-                setattr(obj, field, value)
+            if per_object_values and obj.pk in per_object_values:
+                for field, value in per_object_values[obj.pk].items():
+                    setattr(obj, field, value)
+            else:
+                for field, value in kwargs.items():
+                    setattr(obj, field, value)
 
         # Check if we're in a bulk operation context to prevent double hook execution
         from django_bulk_hooks.context import get_bypass_hooks
-
         current_bypass_hooks = get_bypass_hooks()
-
+        
         # If we're in a bulk operation context, skip hooks to prevent double execution
         if current_bypass_hooks:
             logger.debug("update: skipping hooks (bulk context)")
@@ -90,9 +103,29 @@ class HookQuerySetMixin:
 
         # Use Django's built-in update logic directly
         # Call the base QuerySet implementation to avoid recursion
-        # Use original kwargs so Django can handle subqueries at database level
         update_count = super().update(**kwargs)
 
+        # If we used Subquery objects, refresh the instances to get computed values
+        if has_subquery and instances:
+            # Simple refresh of model fields without fetching related objects
+            # Subquery updates only affect the model's own fields, not relationships
+            refreshed_instances = {
+                obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)
+            }
+
+            # Bulk update all instances in memory
+            for instance in instances:
+                if instance.pk in refreshed_instances:
+                    refreshed_instance = refreshed_instances[instance.pk]
+                    # Update all fields except primary key
+                    for field in model_cls._meta.fields:
+                        if field.name != "id":
+                            setattr(
+                                instance,
+                                field.name,
+                                getattr(refreshed_instance, field.name),
+                            )
+
         # Run AFTER_UPDATE hooks only for standalone updates
         if not current_bypass_hooks:
             logger.debug("update: running AFTER_UPDATE")
@@ -102,61 +135,6 @@ class HookQuerySetMixin:
 
         return update_count
 
-    def _resolve_subquery_values(self, kwargs) -> dict[str, Any]:
-        """
-        Resolve Subquery objects to their actual values by evaluating them
-        against the database. This ensures hooks receive resolved values
-        instead of raw Subquery objects.
-        """
-        resolved_kwargs = {}
-
-        # Check if we have any data to evaluate against
-        has_data = self.model._default_manager.exists()
-
-        for field, value in kwargs.items():
-            # Handle Cast expressions
-            if isinstance(value, Cast):
-                if has_data:
-                    # Try to resolve Cast expression
-                    try:
-                        temp_qs = self.model._default_manager.all()
-                        temp_qs = temp_qs.annotate(_temp_field=value)
-                        temp_qs = temp_qs.values("_temp_field")
-                        result = temp_qs.first()
-                        if result is not None:
-                            resolved_kwargs[field] = result["_temp_field"]
-                        else:
-                            resolved_kwargs[field] = value
-                    except Exception:
-                        logger.warning(
-                            f"Failed to resolve Cast expression for field {field}"
-                        )
-                        resolved_kwargs[field] = value
-                else:
-                    # No data to evaluate against, use original
-                    resolved_kwargs[field] = value
-
-            # Handle Subquery expressions
-            elif hasattr(value, "query") and hasattr(value, "resolve_expression"):
-                try:
-                    temp_qs = self.model._default_manager.all()
-                    temp_qs = temp_qs.annotate(_temp_field=value)
-                    temp_qs = temp_qs.values("_temp_field")
-                    result = temp_qs.first()
-                    if result is not None:
-                        resolved_kwargs[field] = result["_temp_field"]
-                    else:
-                        resolved_kwargs[field] = value
-                except Exception:
-                    logger.warning(f"Failed to resolve subquery for field {field}")
-                    resolved_kwargs[field] = value
-
-            # Handle regular values
-            else:
-                resolved_kwargs[field] = value
-
-        return resolved_kwargs
-
     @transaction.atomic
     def bulk_create(
         self,
@@ -168,7 +146,7 @@ class HookQuerySetMixin:
         unique_fields=None,
         bypass_hooks=False,
         bypass_validation=False,
-    ) -> list[Any]:
+    ):
         """
         Insert each of the instances into the database. Behaves like Django's bulk_create,
         but supports multi-table inheritance (MTI) models and hooks. All arguments are supported and
@@ -212,12 +190,12 @@ class HookQuerySetMixin:
 
         # Fire hooks before DB ops
         if not bypass_hooks:
-            ctx = HookContext(model_cls, bypass_hooks=False)  # Pass bypass_hooks
+            ctx = HookContext(model_cls, bypass_hooks=False) # Pass bypass_hooks
             if not bypass_validation:
                 engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
         else:
-            ctx = HookContext(model_cls, bypass_hooks=True)  # Pass bypass_hooks
+            ctx = HookContext(model_cls, bypass_hooks=True) # Pass bypass_hooks
             logger.debug("bulk_create bypassed hooks")
 
         # For MTI models, we need to handle them specially
@@ -259,7 +237,7 @@ class HookQuerySetMixin:
     @transaction.atomic
     def bulk_update(
         self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
-    ) -> int:
+    ):
         """
         Bulk update objects in the database with MTI support.
         """
@@ -273,9 +251,7 @@ class HookQuerySetMixin:
                 f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        logger.debug(
-            f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}"
-        )
+        logger.debug(f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}")
 
         # Check for MTI
         is_mti = False
@@ -291,9 +267,7 @@ class HookQuerySetMixin:
         else:
             logger.debug("bulk_update: hooks bypassed")
             ctx = HookContext(model_cls, bypass_hooks=True)
-            originals = [None] * len(
-                objs
-            )  # Ensure originals is defined for after_update call
+            originals = [None] * len(objs)  # Ensure originals is defined for after_update call
 
         # Handle auto_now fields like Django's update_or_create does
         fields_set = set(fields)
@@ -319,7 +293,27 @@ class HookQuerySetMixin:
                 if k not in ["bypass_hooks", "bypass_validation"]
             }
             logger.debug("Calling Django bulk_update")
-            result = super().bulk_update(objs, fields, **django_kwargs)
+            # Build a per-object concrete value map to avoid leaking expressions into hooks
+            value_map = {}
+            for obj in objs:
+                if obj.pk is None:
+                    continue
+                field_values = {}
+                for field_name in fields:
+                    # Capture raw values assigned on the object (not expressions)
+                    field_values[field_name] = getattr(obj, field_name)
+                if field_values:
+                    value_map[obj.pk] = field_values
+
+            # Make the value map available to the subsequent update() call
+            if value_map:
+                set_bulk_update_value_map(value_map)
+
+            try:
+                result = super().bulk_update(objs, fields, **django_kwargs)
+            finally:
+                # Always clear after the internal update() path finishes
+                set_bulk_update_value_map(None)
             logger.debug(f"Django bulk_update done: {result}")
 
         # Note: We don't run AFTER_UPDATE hooks here to prevent double execution
@@ -331,7 +325,7 @@ class HookQuerySetMixin:
 
         return result
 
-    def _detect_modified_fields(self, new_instances, original_instances) -> set[str]:
+    def _detect_modified_fields(self, new_instances, original_instances):
         """
         Detect fields that were modified during BEFORE_UPDATE hooks by comparing
         new instances with their original values.
@@ -368,7 +362,7 @@ class HookQuerySetMixin:
 
         return modified_fields
 
-    def _get_inheritance_chain(self) -> list[type[models.Model]]:
+    def _get_inheritance_chain(self):
         """
         Get the complete inheritance chain from root parent to current model.
         Returns list of model classes in order: [RootParent, Parent, Child]
@@ -389,7 +383,7 @@ class HookQuerySetMixin:
         chain.reverse()
         return chain
 
-    def _mti_bulk_create(self, objs, inheritance_chain=None, **kwargs) -> list[Any]:
+    def _mti_bulk_create(self, objs, inheritance_chain=None, **kwargs):
         """
         Implements Django's suggested workaround #2 for MTI bulk_create:
         O(n) normal inserts into parent tables to get primary keys back,
@@ -422,9 +416,7 @@ class HookQuerySetMixin:
                 created_objects.extend(batch_result)
         return created_objects
 
-    def _process_mti_bulk_create_batch(
-        self, batch, inheritance_chain, **kwargs
-    ) -> list[Any]:
+    def _process_mti_bulk_create_batch(self, batch, inheritance_chain, **kwargs):
         """
         Process a single batch of objects through the inheritance chain.
         Implements Django's suggested workaround #2: O(n) normal inserts into parent
@@ -626,7 +618,7 @@ class HookQuerySetMixin:
 
         return child_obj
 
-    def _mti_bulk_update(self, objs, fields, **kwargs) -> int:
+    def _mti_bulk_update(self, objs, fields, **kwargs):
         """
         Custom bulk update implementation for MTI models.
         Updates each table in the inheritance chain efficiently using Django's batch_size.
@@ -693,13 +685,18 @@ class HookQuerySetMixin:
 
     def _process_mti_bulk_update_batch(
         self, batch, field_groups, inheritance_chain, **kwargs
-    ) -> int:
+    ):
         """
         Process a single batch of objects for MTI bulk update.
         Updates each table in the inheritance chain for the batch.
         """
         total_updated = 0
 
+        # For MTI, we need to handle parent links correctly
+        # The root model (first in chain) has its own PK
+        # Child models use the parent link to reference the root PK
+        root_model = inheritance_chain[0]
+
         # Get the primary keys from the objects
         # If objects have pk set but are not loaded from DB, use those PKs
         root_pks = []

{django_bulk_hooks-0.1.234.dist-info → django_bulk_hooks-0.1.236.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.234
+Version: 0.1.236
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 Home-page: https://github.com/AugendLimited/django-bulk-hooks
 License: MIT

{django_bulk_hooks-0.1.234.dist-info → django_bulk_hooks-0.1.236.dist-info}/RECORD

@@ -1,7 +1,7 @@
 django_bulk_hooks/__init__.py,sha256=uUgpnb9AWjIAcWNpCMqBcOewSnpJjJYH6cjPbQkzoNU,140
 django_bulk_hooks/conditions.py,sha256=V_f3Di2uCVUjoyfiU4BQCHmI4uUIRSRroApDcXlvnso,6349
 django_bulk_hooks/constants.py,sha256=3x1H1fSUUNo0DZONN7GUVDuySZctTR-jtByBHmAIX5w,303
-django_bulk_hooks/context.py,sha256=_NbGWTq9s66g0vbFIaqN4GlIHWQmFg3EQ44qY8YvvEg,1537
+django_bulk_hooks/context.py,sha256=jlLsqGZbj__J0-iBUp1D6jTrlDEiX3qIo0XlywW4D9I,2244
 django_bulk_hooks/decorators.py,sha256=WD7Jn7QAvY8F4wOsYlIpjoM9-FdHXSKB7hH9ot-lkYQ,4896
 django_bulk_hooks/engine.py,sha256=t_kvgex6_iZEFc5LK-srBTZPe-1bdlYdip5LfWOc6lc,2411
 django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
@@ -9,9 +9,9 @@ django_bulk_hooks/handler.py,sha256=xZt8iNdYF-ACz-MnKMY0co6scWINU5V5wC1lyDn844k,
 django_bulk_hooks/manager.py,sha256=nfWiwU5-yAoxdnQsUMohxtyCpkV0MBv6X3wmipr9eQY,3697
 django_bulk_hooks/models.py,sha256=exnXYVKEVbYAXhChCP8VdWTnKCnm9DiTcokEIBee1I0,4350
 django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
-django_bulk_hooks/queryset.py,sha256=28MtLT3xKEruAEDVNtXVQRrusMtya12yznMAdmIojEs,33850
+django_bulk_hooks/queryset.py,sha256=wRT3g7shlHkpa0p0m5TjuyrS8SQKNmdhpcjdaSSMQHM,33937
 django_bulk_hooks/registry.py,sha256=8UuhniiH5ChSeOKV1UUbqTEiIu25bZXvcHmkaRbxmME,1131
-django_bulk_hooks-0.1.234.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.234.dist-info/METADATA,sha256=bzEaNj562keAtfN9p-z1_KmC8CWNjH6A4M8E1HMu--c,9049
-django_bulk_hooks-0.1.234.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-django_bulk_hooks-0.1.234.dist-info/RECORD,,
+django_bulk_hooks-0.1.236.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.236.dist-info/METADATA,sha256=030mLHnwBTnsBWPmxLBc0KX9Qwrd2Yx0G3VDvZkVTps,9049
+django_bulk_hooks-0.1.236.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+django_bulk_hooks-0.1.236.dist-info/RECORD,,