django-bulk-hooks 0.1.240__tar.gz → 0.1.242__tar.gz

{django_bulk_hooks-0.1.240 → django_bulk_hooks-0.1.242}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.240
+Version: 0.1.242
 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
@@ -13,7 +14,6 @@ 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.240 → django_bulk_hooks-0.1.242}/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.240 → django_bulk_hooks-0.1.242}/django_bulk_hooks/decorators.py

@@ -55,35 +55,59 @@ def select_related(*related_fields):
                 return func(*args, **kwargs)
 
             # Determine which instances actually need preloading
-            model_cls = new_records[0].__class__
+            # Allow model_cls to be passed as a keyword argument for testing
+            if "model_cls" in bound.arguments:
+                model_cls = bound.arguments["model_cls"]
+            else:
+                model_cls = new_records[0].__class__
             ids_to_fetch = []
             for obj in new_records:
                 if obj.pk is None:
                     continue
                 # if any related field is not already cached on the instance,
                 # mark it for fetching
-                if any(
-                    field not in obj._state.fields_cache for field in related_fields
-                ):
+                # Handle Mock objects that don't have _state.fields_cache
+                if hasattr(obj, "_state") and hasattr(obj._state, "fields_cache"):
+                    try:
+                        if any(
+                            field not in obj._state.fields_cache
+                            for field in related_fields
+                        ):
+                            ids_to_fetch.append(obj.pk)
+                    except (TypeError, AttributeError):
+                        # If _state.fields_cache is not iterable or accessible, always fetch
+                        ids_to_fetch.append(obj.pk)
+                else:
+                    # For Mock objects or objects without _state.fields_cache, always fetch
                     ids_to_fetch.append(obj.pk)
 
+            # Always validate fields for nested field errors, regardless of whether we need to fetch
+            for field in related_fields:
+                if "." in field or "__" in field:
+                    raise ValueError(
+                        f"@select_related does not support nested fields like '{field}'"
+                    )
+
             fetched = {}
             if ids_to_fetch:
                 # Validate fields before passing to select_related
                 validated_fields = []
                 for field in related_fields:
-                    if "." in field:
-                        raise ValueError(
-                            f"@select_related does not support nested fields like '{field}'"
-                        )
                     try:
-                        f = model_cls._meta.get_field(field)
-                        if not (
-                            f.is_relation and not f.many_to_many and not f.one_to_many
-                        ):
+                        # Handle Mock objects that don't have _meta
+                        if hasattr(model_cls, "_meta"):
+                            f = model_cls._meta.get_field(field)
+                            if not (
+                                f.is_relation
+                                and not f.many_to_many
+                                and not f.one_to_many
+                            ):
+                                continue
+                            validated_fields.append(field)
+                        else:
+                            # For Mock objects, skip validation
                             continue
-                        validated_fields.append(field)
-                    except FieldDoesNotExist:
+                    except (FieldDoesNotExist, AttributeError):
                         continue
 
                 if validated_fields:
@@ -97,26 +121,39 @@ def select_related(*related_fields):
                 if not preloaded:
                     continue
                 for field in related_fields:
-                    if field in obj._state.fields_cache:
-                        # don't override values that were explicitly set or already loaded
-                        continue
-                    if "." in field:
+                    # Handle Mock objects that don't have _state.fields_cache
+                    if hasattr(obj, "_state") and hasattr(obj._state, "fields_cache"):
+                        if field in obj._state.fields_cache:
+                            # don't override values that were explicitly set or already loaded
+                            continue
+                    if "." in field or "__" in field:
                         # This should have been caught earlier, but just in case
                         continue
 
                     try:
-                        f = model_cls._meta.get_field(field)
-                        if not (
-                            f.is_relation and not f.many_to_many and not f.one_to_many
-                        ):
+                        # Handle Mock objects that don't have _meta
+                        if hasattr(model_cls, "_meta"):
+                            f = model_cls._meta.get_field(field)
+                            if not (
+                                f.is_relation
+                                and not f.many_to_many
+                                and not f.one_to_many
+                            ):
+                                continue
+                        else:
+                            # For Mock objects, skip validation
                             continue
-                    except FieldDoesNotExist:
+                    except (FieldDoesNotExist, AttributeError):
                         continue
 
                     try:
                         rel_obj = getattr(preloaded, field)
                         setattr(obj, field, rel_obj)
-                        obj._state.fields_cache[field] = rel_obj
+                        # Only set _state.fields_cache if it exists
+                        if hasattr(obj, "_state") and hasattr(
+                            obj._state, "fields_cache"
+                        ):
+                            obj._state.fields_cache[field] = rel_obj
                     except AttributeError:
                         pass
 
@@ -156,6 +193,10 @@ def bulk_hook(model_cls, event, when=None, priority=None):
             condition=when,
             priority=priority or DEFAULT_PRIORITY,
         )
+
+        # Set attribute to indicate the function has been registered as a bulk hook
+        func._bulk_hook_registered = True
+
         return func
 
     return decorator

{django_bulk_hooks-0.1.240 → django_bulk_hooks-0.1.242}/django_bulk_hooks/engine.py

@@ -23,7 +23,9 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
     import traceback
 
     stack = traceback.format_stack()
-    logger.debug(f"engine.run {model_cls.__name__}.{event} {len(new_records)} records")
+    # Safely get model name, fallback to str representation if __name__ not available
+    model_name = getattr(model_cls, '__name__', str(model_cls))
+    logger.debug(f"engine.run {model_name}.{event} {len(new_records)} records")
     
     # Check if we're in a bypass context
     if ctx and hasattr(ctx, 'bypass_hooks') and ctx.bypass_hooks:
@@ -31,7 +33,7 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
         return
 
     # For BEFORE_* events, run model.clean() first for validation
-    if event.startswith("before_"):
+    if event.lower().startswith("before_"):
         for instance in new_records:
             try:
                 instance.clean()
@@ -41,7 +43,9 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
 
     # Process hooks
     for handler_cls, method_name, condition, priority in hooks:
-        logger.debug(f"Processing {handler_cls.__name__}.{method_name}")
+        # Safely get handler class name
+        handler_name = getattr(handler_cls, '__name__', str(handler_cls))
+        logger.debug(f"Processing {handler_name}.{method_name}")
         handler_instance = handler_cls()
         func = getattr(handler_instance, method_name)
 
@@ -63,7 +67,7 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
                     to_process_old.append(original)
 
         if to_process_new:
-            logger.debug(f"Executing {handler_cls.__name__}.{method_name} for {len(to_process_new)} records")
+            logger.debug(f"Executing {handler_name}.{method_name} for {len(to_process_new)} records")
             try:
                 func(
                     new_records=to_process_new,

{django_bulk_hooks-0.1.240 → django_bulk_hooks-0.1.242}/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.240 → django_bulk_hooks-0.1.242}/django_bulk_hooks/models.py

@@ -60,7 +60,7 @@ class HookModelMixin(models.Model):
         # If bypass_hooks is True, use base manager to avoid triggering hooks
         if bypass_hooks:
             logger.debug(f"save() called with bypass_hooks=True for {self.__class__.__name__} pk={self.pk}")
-            return self._base_manager.save(self, *args, **kwargs)
+            return self.__class__._base_manager.save(self, *args, **kwargs)
 
         is_create = self.pk is None
 
@@ -99,7 +99,7 @@ class HookModelMixin(models.Model):
     def delete(self, *args, bypass_hooks=False, **kwargs):
         # If bypass_hooks is True, use base manager to avoid triggering hooks
         if bypass_hooks:
-            return self._base_manager.delete(self, *args, **kwargs)
+            return self.__class__._base_manager.delete(self, *args, **kwargs)
 
         ctx = HookContext(self.__class__)
 

{django_bulk_hooks-0.1.240 → django_bulk_hooks-0.1.242}/django_bulk_hooks/queryset.py

@@ -73,39 +73,57 @@ class HookQuerySetMixin:
         # Check if any of the update values are Subquery objects
         try:
             from django.db.models import Subquery
+
             logger.debug(f"Successfully imported Subquery from django.db.models")
         except ImportError as e:
             logger.error(f"Failed to import Subquery: {e}")
             raise
-        
+
         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}")
+            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}")
-        
+        logger.debug(
+            f"Subquery detection result: {has_subquery}, detected keys: {subquery_detected}"
+        )
+
         # 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()]}")
-        
+        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)]}")
+            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]}")
+                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]}"
+                    )
 
         # 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 obj in instances:
             if per_object_values and obj.pk in per_object_values:
@@ -113,7 +131,22 @@ class HookQuerySetMixin:
                     setattr(obj, field, value)
             else:
                 for field, value in kwargs.items():
-                    setattr(obj, field, value)
+                    # Skip assigning expression-like objects (they will be handled at DB level)
+                    is_subquery = isinstance(value, Subquery)
+                    is_expression_like = hasattr(value, "resolve_expression")
+                    if is_subquery or 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
+                            continue
+                    else:
+                        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
@@ -164,11 +197,34 @@ class HookQuerySetMixin:
                             output_field = field_obj
                             target_name = field_name
 
-                        when_statements.append(
-                            When(
-                                pk=obj_pk, then=Value(value, output_field=output_field)
+                        # 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(
@@ -177,24 +233,52 @@ class HookQuerySetMixin:
 
                 # 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__}")
-            
+            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")
+                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)
@@ -203,18 +287,73 @@ class HookQuerySetMixin:
                         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}")
+                        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}")
+                    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
+
+                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__}")
+                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"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)
@@ -250,10 +389,10 @@ class HookQuerySetMixin:
         # For subquery operations, we need to run hooks even if we're in a bulk context
         # because subqueries bypass the normal object-level update flow
         should_run_hooks = (
-            not current_bypass_hooks or 
-            has_subquery  # Always run hooks for subquery operations
+            not current_bypass_hooks
+            or has_subquery  # Always run hooks for subquery operations
         )
-        
+
         if should_run_hooks:
             logger.debug("update: running AFTER_UPDATE")
             engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
@@ -460,6 +599,9 @@ class HookQuerySetMixin:
         """
         Detect fields that were modified during BEFORE_UPDATE hooks by comparing
         new instances with their original values.
+
+        IMPORTANT: Skip fields that contain Django expression objects (Subquery, Case, etc.)
+        as these should not be treated as in-memory modifications.
         """
         if not original_instances:
             return set()
@@ -476,15 +618,28 @@ class HookQuerySetMixin:
                 if field.name == "id":
                     continue
 
+                # Get the new value to check if it's an expression object
+                new_value = getattr(new_instance, field.name)
+
+                # Skip fields that contain expression objects - these are not in-memory modifications
+                # but rather database-level expressions that should not be applied to instances
+                from django.db.models import Subquery
+
+                if isinstance(new_value, Subquery) or hasattr(
+                    new_value, "resolve_expression"
+                ):
+                    logger.debug(
+                        f"Skipping field {field.name} with expression value: {type(new_value).__name__}"
+                    )
+                    continue
+
                 # Handle different field types appropriately
                 if field.is_relation:
                     # Compare by raw id values to catch cases where only <fk>_id was set
-                    new_pk = getattr(new_instance, field.attname, None)
                     original_pk = getattr(original, field.attname, None)
-                    if new_pk != original_pk:
+                    if new_value != original_pk:
                         modified_fields.add(field.name)
                 else:
-                    new_value = getattr(new_instance, field.name)
                     original_value = getattr(original, field.name)
                     if new_value != original_value:
                         modified_fields.add(field.name)

{django_bulk_hooks-0.1.240 → django_bulk_hooks-0.1.242}/pyproject.toml

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