django-bulk-hooks 0.1.249__tar.gz → 0.1.251__tar.gz

{django_bulk_hooks-0.1.249 → django_bulk_hooks-0.1.251}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.249
+Version: 0.1.251
 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
 Keywords: django,bulk,hooks
 Author: Konrad Beck
@@ -14,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Django (>=4.0)
+Project-URL: Homepage, https://github.com/AugendLimited/django-bulk-hooks
 Project-URL: Repository, https://github.com/AugendLimited/django-bulk-hooks
 Description-Content-Type: text/markdown
 

{django_bulk_hooks-0.1.249 → django_bulk_hooks-0.1.251}/django_bulk_hooks/__init__.py

@@ -1,4 +1,4 @@
-from django_bulk_hooks.handler import Hook as HookClass
-from django_bulk_hooks.manager import BulkHookManager
-
-__all__ = ["BulkHookManager", "HookClass"]
+from django_bulk_hooks.handler import Hook as HookClass
+from django_bulk_hooks.manager import BulkHookManager
+
+__all__ = ["BulkHookManager", "HookClass"]

{django_bulk_hooks-0.1.249 → django_bulk_hooks-0.1.251}/django_bulk_hooks/handler.py

@@ -1,188 +1,188 @@
-import logging
-import threading
-from collections import deque
-
-from django.db import transaction
-
-from django_bulk_hooks.registry import get_hooks, register_hook
-
-logger = logging.getLogger(__name__)
-
-
-# Thread-local hook context and hook state
-class HookVars(threading.local):
-    def __init__(self):
-        self.new = None
-        self.old = None
-        self.event = None
-        self.model = None
-        self.depth = 0
-
-
-hook_vars = HookVars()
-
-# Hook queue per thread
-_hook_context = threading.local()
-
-
-def get_hook_queue():
-    if not hasattr(_hook_context, "queue"):
-        _hook_context.queue = deque()
-    return _hook_context.queue
-
-
-class HookContextState:
-    @property
-    def is_before(self):
-        return hook_vars.event.startswith("before_") if hook_vars.event else False
-
-    @property
-    def is_after(self):
-        return hook_vars.event.startswith("after_") if hook_vars.event else False
-
-    @property
-    def is_create(self):
-        return "create" in hook_vars.event if hook_vars.event else False
-
-    @property
-    def is_update(self):
-        return "update" in hook_vars.event if hook_vars.event else False
-
-    @property
-    def new(self):
-        return hook_vars.new
-
-    @property
-    def old(self):
-        return hook_vars.old
-
-    @property
-    def model(self):
-        return hook_vars.model
-
-
-HookContext = HookContextState()
-
-
-class HookMeta(type):
-    _registered = set()
-
-    def __new__(mcs, name, bases, namespace):
-        cls = super().__new__(mcs, name, bases, namespace)
-        for method_name, method in namespace.items():
-            if hasattr(method, "hooks_hooks"):
-                for model_cls, event, condition, priority in method.hooks_hooks:
-                    key = (model_cls, event, cls, method_name)
-                    if key not in HookMeta._registered:
-                        register_hook(
-                            model=model_cls,
-                            event=event,
-                            handler_cls=cls,
-                            method_name=method_name,
-                            condition=condition,
-                            priority=priority,
-                        )
-                        HookMeta._registered.add(key)
-        return cls
-
-
-class Hook(metaclass=HookMeta):
-    @classmethod
-    def handle(
-        cls,
-        event: str,
-        model: type,
-        *,
-        new_records: list = None,
-        old_records: list = None,
-        **kwargs,
-    ) -> None:
-        queue = get_hook_queue()
-        queue.append((cls, event, model, new_records, old_records, kwargs))
-        logger.debug(f"Added item to queue: {event}, depth: {hook_vars.depth}")
-
-        # If we're already processing hooks (depth > 0), don't process the queue
-        # The outermost call will process the entire queue
-        if hook_vars.depth > 0:
-            logger.debug(f"Depth > 0, returning without processing queue")
-            return
-
-        # Process the entire queue
-        logger.debug(f"Processing queue with {len(queue)} items")
-        while queue:
-            item = queue.popleft()
-            if len(item) == 6:
-                cls_, event_, model_, new_, old_, kw_ = item
-                logger.debug(f"Processing queue item: {event_}")
-                # Call _process on the Hook class, not the calling class
-                Hook._process(event_, model_, new_, old_, **kw_)
-            else:
-                logger.warning(f"Invalid queue item format: {item}")
-                continue
-
-    @classmethod
-    def _process(
-        cls,
-        event,
-        model,
-        new_records,
-        old_records,
-        **kwargs,
-    ):
-        hook_vars.depth += 1
-        hook_vars.new = new_records
-        hook_vars.old = old_records
-        hook_vars.event = event
-        hook_vars.model = model
-
-        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
-        logger.debug(f"Found {len(hooks)} hooks for {event}")
-
-        def _execute():
-            logger.debug(f"Executing {len(hooks)} hooks for {event}")
-            new_local = new_records or []
-            old_local = old_records or []
-            if len(old_local) < len(new_local):
-                old_local += [None] * (len(new_local) - len(old_local))
-
-            for handler_cls, method_name, condition, priority in hooks:
-                logger.debug(f"Processing hook {handler_cls.__name__}.{method_name}")
-                if condition is not None:
-                    checks = [
-                        condition.check(n, o) for n, o in zip(new_local, old_local)
-                    ]
-                    if not any(checks):
-                        logger.debug(f"Condition failed for {handler_cls.__name__}.{method_name}")
-                        continue
-
-                handler = handler_cls()
-                method = getattr(handler, method_name)
-                logger.debug(f"Executing {handler_cls.__name__}.{method_name}")
-
-                try:
-                    method(
-                        new_records=new_local,
-                        old_records=old_local,
-                        **kwargs,
-                    )
-                    logger.debug(f"Successfully executed {handler_cls.__name__}.{method_name}")
-                except Exception:
-                    logger.exception(
-                        "Error in hook %s.%s", handler_cls.__name__, method_name
-                    )
-
-        conn = transaction.get_connection()
-        logger.debug(f"Transaction in_atomic_block: {conn.in_atomic_block}, event: {event}")
-        try:
-            if conn.in_atomic_block and event.startswith("after_"):
-                logger.debug(f"Deferring {event} to on_commit")
-                transaction.on_commit(_execute)
-            else:
-                logger.debug(f"Executing {event} immediately")
-                _execute()
-        finally:
-            hook_vars.new = None
-            hook_vars.old = None
-            hook_vars.event = None
-            hook_vars.model = None
-            hook_vars.depth -= 1
+import logging
+import threading
+from collections import deque
+
+from django.db import transaction
+
+from django_bulk_hooks.registry import get_hooks, register_hook
+
+logger = logging.getLogger(__name__)
+
+
+# Thread-local hook context and hook state
+class HookVars(threading.local):
+    def __init__(self):
+        self.new = None
+        self.old = None
+        self.event = None
+        self.model = None
+        self.depth = 0
+
+
+hook_vars = HookVars()
+
+# Hook queue per thread
+_hook_context = threading.local()
+
+
+def get_hook_queue():
+    if not hasattr(_hook_context, "queue"):
+        _hook_context.queue = deque()
+    return _hook_context.queue
+
+
+class HookContextState:
+    @property
+    def is_before(self):
+        return hook_vars.event.startswith("before_") if hook_vars.event else False
+
+    @property
+    def is_after(self):
+        return hook_vars.event.startswith("after_") if hook_vars.event else False
+
+    @property
+    def is_create(self):
+        return "create" in hook_vars.event if hook_vars.event else False
+
+    @property
+    def is_update(self):
+        return "update" in hook_vars.event if hook_vars.event else False
+
+    @property
+    def new(self):
+        return hook_vars.new
+
+    @property
+    def old(self):
+        return hook_vars.old
+
+    @property
+    def model(self):
+        return hook_vars.model
+
+
+HookContext = HookContextState()
+
+
+class HookMeta(type):
+    _registered = set()
+
+    def __new__(mcs, name, bases, namespace):
+        cls = super().__new__(mcs, name, bases, namespace)
+        for method_name, method in namespace.items():
+            if hasattr(method, "hooks_hooks"):
+                for model_cls, event, condition, priority in method.hooks_hooks:
+                    key = (model_cls, event, cls, method_name)
+                    if key not in HookMeta._registered:
+                        register_hook(
+                            model=model_cls,
+                            event=event,
+                            handler_cls=cls,
+                            method_name=method_name,
+                            condition=condition,
+                            priority=priority,
+                        )
+                        HookMeta._registered.add(key)
+        return cls
+
+
+class Hook(metaclass=HookMeta):
+    @classmethod
+    def handle(
+        cls,
+        event: str,
+        model: type,
+        *,
+        new_records: list = None,
+        old_records: list = None,
+        **kwargs,
+    ) -> None:
+        queue = get_hook_queue()
+        queue.append((cls, event, model, new_records, old_records, kwargs))
+        logger.debug(f"Added item to queue: {event}, depth: {hook_vars.depth}")
+
+        # If we're already processing hooks (depth > 0), don't process the queue
+        # The outermost call will process the entire queue
+        if hook_vars.depth > 0:
+            logger.debug(f"Depth > 0, returning without processing queue")
+            return
+
+        # Process the entire queue
+        logger.debug(f"Processing queue with {len(queue)} items")
+        while queue:
+            item = queue.popleft()
+            if len(item) == 6:
+                cls_, event_, model_, new_, old_, kw_ = item
+                logger.debug(f"Processing queue item: {event_}")
+                # Call _process on the Hook class, not the calling class
+                Hook._process(event_, model_, new_, old_, **kw_)
+            else:
+                logger.warning(f"Invalid queue item format: {item}")
+                continue
+
+    @classmethod
+    def _process(
+        cls,
+        event,
+        model,
+        new_records,
+        old_records,
+        **kwargs,
+    ):
+        hook_vars.depth += 1
+        hook_vars.new = new_records
+        hook_vars.old = old_records
+        hook_vars.event = event
+        hook_vars.model = model
+
+        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
+        logger.debug(f"Found {len(hooks)} hooks for {event}")
+
+        def _execute():
+            logger.debug(f"Executing {len(hooks)} hooks for {event}")
+            new_local = new_records or []
+            old_local = old_records or []
+            if len(old_local) < len(new_local):
+                old_local += [None] * (len(new_local) - len(old_local))
+
+            for handler_cls, method_name, condition, priority in hooks:
+                logger.debug(f"Processing hook {handler_cls.__name__}.{method_name}")
+                if condition is not None:
+                    checks = [
+                        condition.check(n, o) for n, o in zip(new_local, old_local)
+                    ]
+                    if not any(checks):
+                        logger.debug(f"Condition failed for {handler_cls.__name__}.{method_name}")
+                        continue
+
+                handler = handler_cls()
+                method = getattr(handler, method_name)
+                logger.debug(f"Executing {handler_cls.__name__}.{method_name}")
+
+                try:
+                    method(
+                        new_records=new_local,
+                        old_records=old_local,
+                        **kwargs,
+                    )
+                    logger.debug(f"Successfully executed {handler_cls.__name__}.{method_name}")
+                except Exception:
+                    logger.exception(
+                        "Error in hook %s.%s", handler_cls.__name__, method_name
+                    )
+
+        conn = transaction.get_connection()
+        logger.debug(f"Transaction in_atomic_block: {conn.in_atomic_block}, event: {event}")
+        try:
+            if conn.in_atomic_block and event.startswith("after_"):
+                logger.debug(f"Deferring {event} to on_commit")
+                transaction.on_commit(_execute)
+            else:
+                logger.debug(f"Executing {event} immediately")
+                _execute()
+        finally:
+            hook_vars.new = None
+            hook_vars.old = None
+            hook_vars.event = None
+            hook_vars.model = None
+            hook_vars.depth -= 1

{django_bulk_hooks-0.1.249 → django_bulk_hooks-0.1.251}/django_bulk_hooks/queryset.py

@@ -1,9 +1,11 @@
 import logging
 
 from django.db import models, transaction
-from django.db.models import AutoField, Case, Field, Subquery, Value, When
+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,12 +20,9 @@ from django_bulk_hooks.constants import (
 from django_bulk_hooks.context import (
     HookContext,
     get_bulk_update_value_map,
-    get_bypass_hooks,
     set_bulk_update_value_map,
 )
 
-logger = logging.getLogger(__name__)
-
 
 class HookQuerySetMixin:
     """
@@ -46,6 +45,21 @@ class HookQuerySetMixin:
         # Then run business logic hooks
         engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
 
+        # Before deletion, ensure all related fields are properly cached
+        # to avoid DoesNotExist errors in AFTER_DELETE hooks
+        for obj in objs:
+            if obj.pk is not None:
+                # Cache all foreign key relationships by accessing them
+                for field in model_cls._meta.fields:
+                    if field.is_relation and not field.many_to_many and not field.one_to_many:
+                        try:
+                            # Access the related field to cache it before deletion
+                            getattr(obj, field.name)
+                        except Exception:
+                            # If we can't access the field (e.g., already deleted, no permission, etc.)
+                            # continue with other fields
+                            pass
+
         # Use Django's standard delete() method
         result = super().delete()
 
@@ -56,81 +70,372 @@ class HookQuerySetMixin:
 
     @transaction.atomic
     def update(self, **kwargs):
-        """Simplified update method that handles hooks cleanly."""
         logger.debug(f"Entering update method with {len(kwargs)} kwargs")
         instances = list(self)
         if not instances:
             return 0
 
         model_cls = self.model
-        pks = [obj.pk for obj in instances if obj.pk is not None]
-
-        # For test compatibility - if no PKs, create mock PKs
-        if not pks and instances:
-            for i, instance in enumerate(instances):
-                if instance.pk is None:
-                    instance.pk = i + 1
-            pks = [obj.pk for obj in instances]
+        pks = [obj.pk for obj in instances]
 
-        # Load originals for hook comparison
+        # Load originals for hook comparison and ensure they match the order of instances
+        # Use the base manager to avoid recursion
         original_map = {
             obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)
         }
         originals = [original_map.get(obj.pk) for obj in instances]
 
-        # Check for Subquery updates
-        from django.db.models import Subquery, Value
+        # Check if any of the update values are Subquery objects
+        try:
+            from django.db.models import Subquery
 
-        has_subquery = any(isinstance(v, Subquery) for v in kwargs.values())
-        logger.debug(f"Subquery detection result: {has_subquery}")
+            logger.debug(f"Successfully imported Subquery from django.db.models")
+        except ImportError as e:
+            logger.error(f"Failed to import Subquery: {e}")
+            raise
 
-        # Skip hooks if bypassed
-        from django_bulk_hooks.context import (
-            get_bulk_update_value_map,
-            get_bypass_hooks,
+        logger.debug(f"Checking for Subquery objects in {len(kwargs)} kwargs")
+
+        subquery_detected = []
+        for key, value in kwargs.items():
+            is_subquery = isinstance(value, Subquery)
+            logger.debug(
+                f"Key '{key}': type={type(value).__name__}, is_subquery={is_subquery}"
+            )
+            if is_subquery:
+                subquery_detected.append(key)
+
+        has_subquery = len(subquery_detected) > 0
+        logger.debug(
+            f"Subquery detection result: {has_subquery}, detected keys: {subquery_detected}"
         )
 
-        if get_bypass_hooks():
-            logger.debug("update: hooks explicitly bypassed")
-            return super().update(**kwargs)
+        # Debug logging for Subquery detection
+        logger.debug(f"Update kwargs: {list(kwargs.keys())}")
+        logger.debug(
+            f"Update kwargs types: {[(k, type(v).__name__) for k, v in kwargs.items()]}"
+        )
+
+        if has_subquery:
+            logger.debug(
+                f"Detected Subquery in update: {[k for k, v in kwargs.items() if isinstance(v, Subquery)]}"
+            )
+        else:
+            # Check if we missed any Subquery objects
+            for k, v in kwargs.items():
+                if hasattr(v, "query") and hasattr(v, "resolve_expression"):
+                    logger.warning(
+                        f"Potential Subquery-like object detected but not recognized: {k}={type(v).__name__}"
+                    )
+                    logger.warning(
+                        f"Object attributes: query={hasattr(v, 'query')}, resolve_expression={hasattr(v, 'resolve_expression')}"
+                    )
+                    logger.warning(
+                        f"Object dir: {[attr for attr in dir(v) if not attr.startswith('_')][:10]}"
+                    )
 
-        ctx = HookContext(model_cls, bypass_hooks=False)
-        logger.debug("update: running hooks with Salesforce-style behavior")
+        # Apply field updates to instances
+        # If a per-object value map exists (from bulk_update), prefer it over kwargs
+        # IMPORTANT: Do not assign Django expression objects (e.g., Subquery/Case/F)
+        # to in-memory instances before running BEFORE_UPDATE hooks. Hooks must not
+        # receive unresolved expression objects.
+        per_object_values = get_bulk_update_value_map()
 
+        # For Subquery updates, skip all in-memory field assignments to prevent
+        # expression objects from reaching hooks
         if has_subquery:
-            # For Subquery updates: database first, then hooks
-            logger.debug("Using two-stage update for Subquery")
+            logger.debug(
+                "Skipping in-memory field assignments due to Subquery detection"
+            )
+        else:
+            for obj in instances:
+                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():
+                        # Skip assigning expression-like objects (they will be handled at DB level)
+                        is_expression_like = hasattr(value, "resolve_expression")
+                        if is_expression_like:
+                            # Special-case Value() which can be unwrapped safely
+                            if isinstance(value, Value):
+                                try:
+                                    setattr(obj, field, value.value)
+                                except Exception:
+                                    # If Value cannot be unwrapped for any reason, skip assignment
+                                    continue
+                            else:
+                                # Do not assign unresolved expressions to in-memory objects
+                                logger.debug(
+                                    f"Skipping assignment of expression {type(value).__name__} to field {field}"
+                                )
+                                continue
+                        else:
+                            setattr(obj, field, value)
+
+        # Salesforce-style trigger behavior: Always run hooks, rely on Django's stack overflow protection
+        from django_bulk_hooks.context import get_bypass_hooks
+
+        current_bypass_hooks = get_bypass_hooks()
+
+        # Only skip hooks if explicitly bypassed (not for recursion prevention)
+        if current_bypass_hooks:
+            logger.debug("update: hooks explicitly bypassed")
+            ctx = HookContext(model_cls, bypass_hooks=True)
+        else:
+            # Always run hooks - Django will handle stack overflow protection
+            logger.debug("update: running hooks with Salesforce-style behavior")
+            ctx = HookContext(model_cls, bypass_hooks=False)
+
+            # Run validation hooks first
+            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
+
+            # For Subquery updates, skip BEFORE_UPDATE hooks here - they'll run after refresh
+            if not has_subquery:
+                # Then run BEFORE_UPDATE hooks for non-Subquery updates
+                engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
+
+            # Persist any additional field mutations made by BEFORE_UPDATE hooks.
+            # Build CASE statements per modified field not already present in kwargs.
+            # Note: For Subquery updates, this will be empty since hooks haven't run yet
+            # For Subquery updates, hook modifications are handled later via bulk_update
+            if not has_subquery:
+                modified_fields = self._detect_modified_fields(instances, originals)
+                extra_fields = [f for f in modified_fields if f not in kwargs]
+            else:
+                extra_fields = []  # Skip for Subquery updates
+
+            if extra_fields:
+                case_statements = {}
+                for field_name in extra_fields:
+                    try:
+                        field_obj = model_cls._meta.get_field(field_name)
+                    except Exception:
+                        # Skip unknown fields
+                        continue
+
+                    when_statements = []
+                    for obj in instances:
+                        obj_pk = getattr(obj, "pk", None)
+                        if obj_pk is None:
+                            continue
+
+                        # Determine value and output field
+                        if getattr(field_obj, "is_relation", False):
+                            # For FK fields, store the raw id and target field output type
+                            value = getattr(obj, field_obj.attname, None)
+                            output_field = field_obj.target_field
+                            target_name = (
+                                field_obj.attname
+                            )  # use column name (e.g., fk_id)
+                        else:
+                            value = getattr(obj, field_name)
+                            output_field = field_obj
+                            target_name = field_name
+
+                        # Special handling for Subquery and other expression values in CASE statements
+                        if isinstance(value, Subquery):
+                            logger.debug(
+                                f"Creating When statement with Subquery for {field_name}"
+                            )
+                            # Ensure the Subquery has proper output_field
+                            if (
+                                not hasattr(value, "output_field")
+                                or value.output_field is None
+                            ):
+                                value.output_field = output_field
+                                logger.debug(
+                                    f"Set output_field for Subquery in When statement to {output_field}"
+                                )
+                            when_statements.append(When(pk=obj_pk, then=value))
+                        elif hasattr(value, "resolve_expression"):
+                            # Handle other expression objects (Case, F, etc.)
+                            logger.debug(
+                                f"Creating When statement with expression for {field_name}: {type(value).__name__}"
+                            )
+                            when_statements.append(When(pk=obj_pk, then=value))
+                        else:
+                            when_statements.append(
+                                When(
+                                    pk=obj_pk,
+                                    then=Value(value, output_field=output_field),
+                                )
+                            )
+
+                    if when_statements:
+                        case_statements[target_name] = Case(
+                            *when_statements, output_field=output_field
+                        )
 
-            # Stage 1: Execute the database update first
-            logger.debug("Stage 1: Executing Subquery update")
-            update_count = super().update(**kwargs)
-            logger.debug(f"Subquery update completed, affected {update_count} records")
+                # Merge extra CASE updates into kwargs for DB update
+                if case_statements:
+                    logger.debug(
+                        f"Adding case statements to kwargs: {list(case_statements.keys())}"
+                    )
+                    for field_name, case_stmt in case_statements.items():
+                        logger.debug(
+                            f"Case statement for {field_name}: {type(case_stmt).__name__}"
+                        )
+                        # Check if the case statement contains Subquery objects
+                        if hasattr(case_stmt, "get_source_expressions"):
+                            source_exprs = case_stmt.get_source_expressions()
+                            for expr in source_exprs:
+                                if isinstance(expr, Subquery):
+                                    logger.debug(
+                                        f"Case statement for {field_name} contains Subquery"
+                                    )
+                                elif hasattr(expr, "get_source_expressions"):
+                                    # Check nested expressions (like Value objects)
+                                    nested_exprs = expr.get_source_expressions()
+                                    for nested_expr in nested_exprs:
+                                        if isinstance(nested_expr, Subquery):
+                                            logger.debug(
+                                                f"Case statement for {field_name} contains nested Subquery"
+                                            )
+
+                    kwargs = {**kwargs, **case_statements}
+
+        # Use Django's built-in update logic directly
+        # Call the base QuerySet implementation to avoid recursion
+
+        # Additional safety check: ensure Subquery objects are properly handled
+        # This prevents the "cannot adapt type 'Subquery'" error
+        safe_kwargs = {}
+        logger.debug(f"Processing {len(kwargs)} kwargs for safety check")
+
+        for key, value in kwargs.items():
+            logger.debug(
+                f"Processing key '{key}' with value type {type(value).__name__}"
+            )
+
+            if isinstance(value, Subquery):
+                logger.debug(f"Found Subquery for field {key}")
+                # Ensure Subquery has proper output_field
+                if not hasattr(value, "output_field") or value.output_field is None:
+                    logger.warning(
+                        f"Subquery for field {key} missing output_field, attempting to infer"
+                    )
+                    # Try to infer from the model field
+                    try:
+                        field = model_cls._meta.get_field(key)
+                        logger.debug(f"Inferred field type: {type(field).__name__}")
+                        value = value.resolve_expression(None, None)
+                        value.output_field = field
+                        logger.debug(f"Set output_field to {field}")
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to infer output_field for Subquery on {key}: {e}"
+                        )
+                        raise
+                else:
+                    logger.debug(
+                        f"Subquery for field {key} already has output_field: {value.output_field}"
+                    )
+                safe_kwargs[key] = value
+            elif hasattr(value, "get_source_expressions") and hasattr(
+                value, "resolve_expression"
+            ):
+                # Handle Case statements and other complex expressions
+                logger.debug(
+                    f"Found complex expression for field {key}: {type(value).__name__}"
+                )
+
+                # Check if this expression contains any Subquery objects
+                source_expressions = value.get_source_expressions()
+                has_nested_subquery = False
+
+                for expr in source_expressions:
+                    if isinstance(expr, Subquery):
+                        has_nested_subquery = True
+                        logger.debug(f"Found nested Subquery in {type(value).__name__}")
+                        # Ensure the nested Subquery has proper output_field
+                        if (
+                            not hasattr(expr, "output_field")
+                            or expr.output_field is None
+                        ):
+                            try:
+                                field = model_cls._meta.get_field(key)
+                                expr.output_field = field
+                                logger.debug(
+                                    f"Set output_field for nested Subquery to {field}"
+                                )
+                            except Exception as e:
+                                logger.error(
+                                    f"Failed to set output_field for nested Subquery: {e}"
+                                )
+                                raise
 
-            # Stage 2: Refresh instances with computed values
-            logger.debug("Stage 2: Refreshing instances with Subquery results")
-            refreshed_map = {
+                if has_nested_subquery:
+                    logger.debug(
+                        f"Expression contains Subquery, ensuring proper output_field"
+                    )
+                    # Try to resolve the expression to ensure it's properly formatted
+                    try:
+                        resolved_value = value.resolve_expression(None, None)
+                        safe_kwargs[key] = resolved_value
+                        logger.debug(f"Successfully resolved expression for {key}")
+                    except Exception as e:
+                        logger.error(f"Failed to resolve expression for {key}: {e}")
+                        raise
+                else:
+                    safe_kwargs[key] = value
+            else:
+                logger.debug(
+                    f"Non-Subquery value for field {key}: {type(value).__name__}"
+                )
+                safe_kwargs[key] = value
+
+        logger.debug(f"Safe kwargs keys: {list(safe_kwargs.keys())}")
+        logger.debug(
+            f"Safe kwargs types: {[(k, type(v).__name__) for k, v in safe_kwargs.items()]}"
+        )
+
+        logger.debug(f"Calling super().update() with {len(safe_kwargs)} kwargs")
+        try:
+            update_count = super().update(**safe_kwargs)
+            logger.debug(f"Super update successful, count: {update_count}")
+        except Exception as e:
+            logger.error(f"Super update failed: {e}")
+            logger.error(f"Exception type: {type(e).__name__}")
+            logger.error(f"Safe kwargs that caused failure: {safe_kwargs}")
+            raise
+
+        # If we used Subquery objects, refresh the instances to get computed values
+        # and run BEFORE_UPDATE hooks so HasChanged conditions work correctly
+        if has_subquery and instances and not current_bypass_hooks:
+            logger.debug(
+                "Refreshing instances with Subquery computed values before running hooks"
+            )
+            # 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 and save pre-hook state
             pre_hook_state = {}
             for instance in instances:
-                if instance.pk in refreshed_map:
-                    refreshed = refreshed_map[instance.pk]
-                    # Save pre-hook state for comparison
+                if instance.pk in refreshed_instances:
+                    refreshed_instance = refreshed_instances[instance.pk]
+                    # Save current state before modifying for hook comparison
                     pre_hook_values = {}
                     for field in model_cls._meta.fields:
                         if field.name != "id":
-                            field_value = getattr(refreshed, field.name)
-                            pre_hook_values[field.name] = field_value
-                            setattr(instance, field.name, field_value)
+                            pre_hook_values[field.name] = getattr(
+                                refreshed_instance, field.name
+                            )
+                            setattr(
+                                instance,
+                                field.name,
+                                getattr(refreshed_instance, field.name),
+                            )
                     pre_hook_state[instance.pk] = pre_hook_values
 
-            # Stage 3: Run hooks with refreshed data
-            logger.debug("Stage 3: Running hooks with refreshed instances")
-            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
+            # Now run BEFORE_UPDATE hooks with refreshed instances so conditions work
+            logger.debug("Running BEFORE_UPDATE hooks after Subquery refresh")
             engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
-            # Stage 4: Persist hook modifications
-            logger.debug("Stage 4: Detecting hook modifications for bulk_update")
+            # Check if hooks modified any fields and persist them with bulk_update
             hook_modified_fields = set()
             for instance in instances:
                 if instance.pk in pre_hook_state:
@@ -140,65 +445,22 @@ class HookQuerySetMixin:
                         if current_value != pre_hook_value:
                             hook_modified_fields.add(field_name)
 
+            hook_modified_fields = list(hook_modified_fields)
             if hook_modified_fields:
-                hook_modified_fields = list(hook_modified_fields)
                 logger.debug(
                     f"Running bulk_update for hook-modified fields: {hook_modified_fields}"
                 )
+                # Use bulk_update to persist hook modifications, bypassing hooks to avoid recursion
                 model_cls.objects.bulk_update(
                     instances, hook_modified_fields, bypass_hooks=True
                 )
 
+        # Salesforce-style: Always run AFTER_UPDATE hooks unless explicitly bypassed
+        if not current_bypass_hooks:
+            logger.debug("update: running AFTER_UPDATE")
+            engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
         else:
-            # For regular updates: hooks first, then database
-            logger.debug("Using single-stage update for non-Subquery")
-
-            # Apply field updates to instances
-            per_object_values = get_bulk_update_value_map()
-            for instance in instances:
-                if per_object_values and instance.pk in per_object_values:
-                    for field, value in per_object_values[instance.pk].items():
-                        setattr(instance, field, value)
-                else:
-                    for field, value in kwargs.items():
-                        # Skip assigning expression-like objects (they will be handled at DB level)
-                        if hasattr(value, "resolve_expression"):
-                            # Special-case Value() which can be unwrapped safely
-                            if isinstance(value, Value):
-                                try:
-                                    setattr(instance, field, value.value)
-                                except Exception:
-                                    continue
-                            else:
-                                logger.debug(
-                                    f"Skipping assignment of expression {type(value).__name__} to field {field}"
-                                )
-                                continue
-                        else:
-                            setattr(instance, field, value)
-
-            # Run hooks
-            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
-            engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
-
-            # Execute database update
-            update_count = super().update(**kwargs)
-            logger.debug(f"Super update successful, count: {update_count}")
-
-            # Detect and persist additional hook modifications
-            hook_modified_fields = self._detect_modified_fields(instances, originals)
-            extra_fields = [f for f in hook_modified_fields if f not in kwargs]
-            if extra_fields:
-                logger.debug(
-                    f"Running bulk_update for hook-modified fields: {extra_fields}"
-                )
-                model_cls.objects.bulk_update(
-                    instances, extra_fields, bypass_hooks=True
-                )
-
-        # Always run AFTER_UPDATE hooks
-        logger.debug("update: running AFTER_UPDATE")
-        engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
+            logger.debug("update: AFTER_UPDATE explicitly bypassed")
 
         return update_count
 
@@ -372,14 +634,7 @@ class HookQuerySetMixin:
                 field_values = {}
                 for field_name in fields:
                     # Capture raw values assigned on the object (not expressions)
-                    value = getattr(obj, field_name)
-                    # Skip expression objects that should not be passed to hooks
-                    if hasattr(value, "resolve_expression"):
-                        logger.debug(
-                            f"Skipping expression {type(value).__name__} for field {field_name} in bulk_update value map"
-                        )
-                        continue
-                    field_values[field_name] = value
+                    field_values[field_name] = getattr(obj, field_name)
                 if field_values:
                     value_map[obj.pk] = field_values
 
@@ -907,6 +1162,22 @@ class HookQuerySetMixin:
             ctx = HookContext(model_cls, bypass_hooks=True)
             logger.debug("bulk_delete bypassed hooks")
 
+        # Before deletion, ensure all related fields are properly cached
+        # to avoid DoesNotExist errors in AFTER_DELETE hooks
+        if not bypass_hooks:
+            for obj in objs:
+                if obj.pk is not None:
+                    # Cache all foreign key relationships by accessing them
+                    for field in model_cls._meta.fields:
+                        if field.is_relation and not field.many_to_many and not field.one_to_many:
+                            try:
+                                # Access the related field to cache it before deletion
+                                getattr(obj, field.name)
+                            except Exception:
+                                # If we can't access the field (e.g., already deleted, no permission, etc.)
+                                # continue with other fields
+                                pass
+
         # Use Django's standard delete() method on the queryset
         pks = [obj.pk for obj in objs if obj.pk is not None]
         if pks:

{django_bulk_hooks-0.1.249 → django_bulk_hooks-0.1.251}/pyproject.toml

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