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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.249
+Version: 0.1.250
 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.249 → django_bulk_hooks-0.1.250}/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:
     """
@@ -56,81 +55,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()]}"
+        )
 
-        ctx = HookContext(model_cls, bypass_hooks=False)
-        logger.debug("update: running hooks with Salesforce-style behavior")
+        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]}"
+                    )
+
+        # 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__}"
+            )
 
-            # Stage 2: Refresh instances with computed values
-            logger.debug("Stage 2: Refreshing instances with Subquery results")
-            refreshed_map = {
+            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
+
+                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 +430,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 +619,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
 

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

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