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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.247
+Version: 0.1.249
 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.247 → django_bulk_hooks-0.1.249}/django_bulk_hooks/queryset.py

@@ -1,11 +1,9 @@
 import logging
 
 from django.db import models, transaction
-from django.db.models import AutoField, Case, Field, Value, When
+from django.db.models import AutoField, Case, Field, Subquery, Value, When
 
 from django_bulk_hooks import engine
-
-logger = logging.getLogger(__name__)
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -20,9 +18,12 @@ 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:
     """
@@ -55,365 +56,81 @@ 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]
+        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]
 
-        # Load originals for hook comparison and ensure they match the order of instances
-        # Use the base manager to avoid recursion
+        # Load originals for hook comparison
         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 if any of the update values are Subquery objects
-        try:
-            from django.db.models import Subquery
+        # Check for Subquery updates
+        from django.db.models import Subquery, Value
 
-            logger.debug(f"Successfully imported Subquery from django.db.models")
-        except ImportError as e:
-            logger.error(f"Failed to import Subquery: {e}")
-            raise
+        has_subquery = any(isinstance(v, Subquery) for v in kwargs.values())
+        logger.debug(f"Subquery detection result: {has_subquery}")
 
-        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}"
+        # Skip hooks if bypassed
+        from django_bulk_hooks.context import (
+            get_bulk_update_value_map,
+            get_bypass_hooks,
         )
 
-        # 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]}"
-                    )
-
-        # 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:
-            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:
+        if get_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
-            modified_fields = self._detect_modified_fields(instances, originals)
-            extra_fields = [f for f in modified_fields if f not in kwargs]
-            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),
-                                )
-                            )
+            return super().update(**kwargs)
 
-                    if when_statements:
-                        case_statements[target_name] = Case(
-                            *when_statements, output_field=output_field
-                        )
+        ctx = HookContext(model_cls, bypass_hooks=False)
+        logger.debug("update: running hooks with Salesforce-style behavior")
 
-                # 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
-
-                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
+        if has_subquery:
+            # For Subquery updates: database first, then hooks
+            logger.debug("Using two-stage update for Subquery")
 
-        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()]}"
-        )
+            # 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")
 
-        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 = {
+            # Stage 2: Refresh instances with computed values
+            logger.debug("Stage 2: Refreshing instances with Subquery results")
+            refreshed_map = {
                 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_instances:
-                    refreshed_instance = refreshed_instances[instance.pk]
-                    # Save current state before modifying for hook comparison
+                if instance.pk in refreshed_map:
+                    refreshed = refreshed_map[instance.pk]
+                    # Save pre-hook state for comparison
                     pre_hook_values = {}
                     for field in model_cls._meta.fields:
                         if field.name != "id":
-                            pre_hook_values[field.name] = getattr(refreshed_instance, field.name)
-                            setattr(
-                                instance,
-                                field.name,
-                                getattr(refreshed_instance, field.name),
-                            )
+                            field_value = getattr(refreshed, field.name)
+                            pre_hook_values[field.name] = field_value
+                            setattr(instance, field.name, field_value)
                     pre_hook_state[instance.pk] = pre_hook_values
 
-            # Now run BEFORE_UPDATE hooks with refreshed instances so conditions work
-            logger.debug("Running BEFORE_UPDATE hooks after Subquery refresh")
+            # 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)
             engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
-            # Check if hooks modified any fields and persist them with bulk_update
+            # Stage 4: Persist hook modifications
+            logger.debug("Stage 4: Detecting hook modifications for bulk_update")
             hook_modified_fields = set()
             for instance in instances:
                 if instance.pk in pre_hook_state:
@@ -422,23 +139,66 @@ class HookQuerySetMixin:
                         current_value = getattr(instance, field_name)
                         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:
-            logger.debug("update: AFTER_UPDATE explicitly bypassed")
+            # 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)
 
         return update_count
 
@@ -612,7 +372,14 @@ class HookQuerySetMixin:
                 field_values = {}
                 for field_name in fields:
                     # Capture raw values assigned on the object (not expressions)
-                    field_values[field_name] = getattr(obj, field_name)
+                    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
                 if field_values:
                     value_map[obj.pk] = field_values
 

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

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