django-bulk-hooks 0.1.246__tar.gz → 0.1.248__tar.gz

{django_bulk_hooks-0.1.246 → django_bulk_hooks-0.1.248}/PKG-INFO

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

@@ -1,11 +1,10 @@
 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 +19,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,7 +57,7 @@ class HookQuerySetMixin:
 
     @transaction.atomic
     def update(self, **kwargs):
-        logger.debug(f"Entering update method with {len(kwargs)} kwargs")
+        """Simplified update method that handles hooks cleanly."""
         instances = list(self)
         if not instances:
             return 0
@@ -63,353 +65,72 @@ class HookQuerySetMixin:
         model_cls = self.model
         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
-
-            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")
+        # Check for Subquery updates
+        has_subquery = any(isinstance(v, Subquery) for v in kwargs.values())
 
-        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)
+        # Skip hooks if bypassed
+        if get_bypass_hooks():
+            return super().update(**kwargs)
 
-        has_subquery = len(subquery_detected) > 0
-        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()]}"
-        )
+        ctx = HookContext(model_cls, bypass_hooks=False)
 
         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: database first, then hooks
+            update_count = super().update(**kwargs)
 
-        # 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:
-            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 hooks before database update for both Subquery and non-Subquery cases
-            # Run validation hooks first
-            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
-            # Then run BEFORE_UPDATE hooks
-            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.
-            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),
-                                )
-                            )
-
-                    if when_statements:
-                        case_statements[target_name] = Case(
-                            *when_statements, output_field=output_field
-                        )
-
-                # 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
-
-        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
-        # for AFTER_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 = {
+            # Refresh instances with computed values
+            refreshed_map = {
                 obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)
             }
-
-            # Bulk update all instances in memory
             for instance in instances:
-                if instance.pk in refreshed_instances:
-                    refreshed_instance = refreshed_instances[instance.pk]
-                    # Update all fields except primary key
+                if instance.pk in refreshed_map:
+                    refreshed = refreshed_map[instance.pk]
                     for field in model_cls._meta.fields:
                         if field.name != "id":
                             setattr(
-                                instance,
-                                field.name,
-                                getattr(refreshed_instance, field.name),
+                                instance, field.name, getattr(refreshed, field.name)
                             )
 
-            logger.debug("Running hooks after Subquery refresh")
+            # Run hooks with refreshed data
+            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
+            engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
-        # 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)
+            # Persist hook modifications
+            hook_modified_fields = self._detect_modified_fields(instances, originals)
+            if hook_modified_fields:
+                model_cls.objects.bulk_update(
+                    instances, hook_modified_fields, bypass_hooks=True
+                )
         else:
-            logger.debug("update: AFTER_UPDATE explicitly bypassed")
+            # For regular updates: hooks first, then database
+            # Apply field updates to instances
+            for instance in instances:
+                for field, value in kwargs.items():
+                    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 with hook modifications
+            update_count = super().update(**kwargs)
+
+            # 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:
+                model_cls.objects.bulk_update(
+                    instances, extra_fields, bypass_hooks=True
+                )
+
+        # Always run AFTER_UPDATE hooks
+        engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
 
         return update_count
 

{django_bulk_hooks-0.1.246 → django_bulk_hooks-0.1.248}/pyproject.toml

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