django-bulk-hooks 0.1.221__tar.gz → 0.1.223__tar.gz

{django_bulk_hooks-0.1.221 → django_bulk_hooks-0.1.223}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.221
+Version: 0.1.223
 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.221 → django_bulk_hooks-0.1.223}/django_bulk_hooks/queryset.py

@@ -1,4 +1,5 @@
 import logging
+
 from django.db import models, transaction
 from django.db.models import AutoField, Case, Field, Value, When
 
@@ -70,58 +71,77 @@ class HookQuerySetMixin:
             for value in kwargs.values()
         )
 
-        # Apply field updates to instances
+        # Check if we're in a bulk operation context to prevent double hook execution
+        from django_bulk_hooks.context import get_bypass_hooks
+
+        current_bypass_hooks = get_bypass_hooks()
+
+        # Apply field updates to instances for all cases (needed for hook inspection)
         for obj in instances:
             for field, value in kwargs.items():
+                # For subquery fields, set the original Subquery object temporarily
+                # We'll resolve it after database update if needed
                 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
-        current_bypass_hooks = get_bypass_hooks()
-        
         # If we're in a bulk operation context, skip hooks to prevent double execution
         if current_bypass_hooks:
-            logger.debug("update: skipping hooks (bulk context)")
             ctx = HookContext(model_cls, bypass_hooks=True)
+            # For bulk operations without hooks, execute update
+            update_count = super().update(**kwargs)
         else:
-            logger.debug("update: running hooks (standalone)")
             ctx = HookContext(model_cls, bypass_hooks=False)
-            # 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)
-
-        # Use Django's built-in update logic directly
-        # Call the base QuerySet implementation to avoid recursion
-        update_count = super().update(**kwargs)
-
-        # If we used Subquery objects, refresh the instances to get computed values
-        if has_subquery and instances:
-            # 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
-            for instance in instances:
-                if instance.pk in refreshed_instances:
-                    refreshed_instance = refreshed_instances[instance.pk]
-                    # Update all fields except primary key
-                    for field in model_cls._meta.fields:
-                        if field.name != "id":
-                            setattr(
-                                instance,
-                                field.name,
-                                getattr(refreshed_instance, field.name),
-                            )
+            # For subquery cases, we need special handling
+            if has_subquery:
+                # Run validation hooks first with Subquery objects (if validation doesn't access them)
+                try:
+                    engine.run(
+                        model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx
+                    )
+                except (TypeError, ValueError) as e:
+                    # If validation fails due to Subquery comparison, skip validation for subquery updates
+                    # This is a limitation - validation hooks cannot easily work with unresolved subqueries
+                    logger.warning(
+                        f"Skipping validation hooks for subquery update due to: {e}"
+                    )
+
+                # Execute the database update first to compute subquery values
+                update_count = super().update(**kwargs)
+
+                # Refresh instances to get computed subquery values BEFORE running BEFORE hooks
+                refreshed_instances = {
+                    obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)
+                }
+
+                # Update instances in memory with computed values
+                for instance in instances:
+                    if instance.pk in refreshed_instances:
+                        refreshed_instance = refreshed_instances[instance.pk]
+                        # Update all fields except primary key with the computed values
+                        for field in model_cls._meta.fields:
+                            if field.name != "id":
+                                setattr(
+                                    instance,
+                                    field.name,
+                                    getattr(refreshed_instance, field.name),
+                                )
+
+                # Now run BEFORE_UPDATE hooks with resolved values
+                # Note: This is a trade-off - BEFORE hooks run after DB update for subquery cases
+                engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
+            else:
+                # Normal case without subqueries - run hooks in proper order
+                # 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)
+
+                # Execute update
+                update_count = super().update(**kwargs)
 
         # Run AFTER_UPDATE hooks only for standalone updates
         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: skipping AFTER_UPDATE (bulk context)")
 
         return update_count
 
@@ -180,12 +200,12 @@ class HookQuerySetMixin:
 
         # Fire hooks before DB ops
         if not bypass_hooks:
-            ctx = HookContext(model_cls, bypass_hooks=False) # Pass bypass_hooks
+            ctx = HookContext(model_cls, bypass_hooks=False)  # Pass bypass_hooks
             if not bypass_validation:
                 engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
         else:
-            ctx = HookContext(model_cls, bypass_hooks=True) # Pass bypass_hooks
+            ctx = HookContext(model_cls, bypass_hooks=True)  # Pass bypass_hooks
             logger.debug("bulk_create bypassed hooks")
 
         # For MTI models, we need to handle them specially
@@ -241,7 +261,9 @@ class HookQuerySetMixin:
                 f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        logger.debug(f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}")
+        logger.debug(
+            f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}"
+        )
 
         # Check for MTI
         is_mti = False
@@ -257,7 +279,9 @@ class HookQuerySetMixin:
         else:
             logger.debug("bulk_update: hooks bypassed")
             ctx = HookContext(model_cls, bypass_hooks=True)
-            originals = [None] * len(objs)  # Ensure originals is defined for after_update call
+            originals = [None] * len(
+                objs
+            )  # Ensure originals is defined for after_update call
 
         # Handle auto_now fields like Django's update_or_create does
         fields_set = set(fields)

{django_bulk_hooks-0.1.221 → django_bulk_hooks-0.1.223}/pyproject.toml

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