django-bulk-hooks 0.1.225__tar.gz → 0.1.227__tar.gz

{django_bulk_hooks-0.1.225 → django_bulk_hooks-0.1.227}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.225
+Version: 0.1.227
 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
@@ -14,6 +13,7 @@ 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
 
@@ -59,21 +59,37 @@ from django_bulk_hooks.conditions import WhenFieldHasChanged
 from .models import Account
 
 class AccountHooks(Hook):
-    @hook(AFTER_UPDATE, model=Account, condition=WhenFieldHasChanged("balance"))
-    def log_balance_change(self, new_records, old_records):
-        print("Accounts updated:", [a.pk for a in new_records])
-    
-    @hook(BEFORE_CREATE, model=Account)
-    def before_create(self, new_records, old_records):
-        for account in new_records:
-            if account.balance < 0:
-                raise ValueError("Account cannot have negative balance")
-    
-    @hook(AFTER_DELETE, model=Account)
-    def after_delete(self, new_records, old_records):
-        print("Accounts deleted:", [a.pk for a in old_records])
+    @hook(AFTER_UPDATE, condition=WhenFieldHasChanged('balance'))
+    def _notify_balance_change(self, new_records, old_records, **kwargs):
+        for new_record, old_record in zip(new_records, old_records):
+            if old_record and new_record.balance != old_record.balance:
+                print(f"Balance changed from {old_record.balance} to {new_record.balance}")
+```
+
+### Bulk Operations with Hooks
+
+```python
+# For complete hook execution, use the update() method
+accounts = Account.objects.filter(active=True)
+accounts.update(balance=1000)  # Runs all hooks automatically
+
+# For bulk operations with hooks
+accounts = Account.objects.filter(active=True)
+instances = list(accounts)
+
+# bulk_update now runs complete hook cycle by default
+accounts.bulk_update(instances, ['balance'])  # Runs VALIDATE → BEFORE → DB update → AFTER
+
+# To skip hooks (for performance or when called from update())
+accounts.bulk_update(instances, ['balance'], bypass_hooks=True)
 ```
 
+### Understanding Hook Execution
+
+- **`update()` method**: Runs complete hook cycle (VALIDATE → BEFORE → DB update → AFTER)
+- **`bulk_update()` method**: Runs complete hook cycle (VALIDATE → BEFORE → DB update → AFTER)
+- **`bypass_hooks=True`**: Skips all hooks for performance or to prevent double execution
+
 ## 🛠 Supported Hook Events
 
 - `BEFORE_CREATE`, `AFTER_CREATE`

{django_bulk_hooks-0.1.225 → django_bulk_hooks-0.1.227}/README.md

@@ -40,21 +40,37 @@ from django_bulk_hooks.conditions import WhenFieldHasChanged
 from .models import Account
 
 class AccountHooks(Hook):
-    @hook(AFTER_UPDATE, model=Account, condition=WhenFieldHasChanged("balance"))
-    def log_balance_change(self, new_records, old_records):
-        print("Accounts updated:", [a.pk for a in new_records])
-    
-    @hook(BEFORE_CREATE, model=Account)
-    def before_create(self, new_records, old_records):
-        for account in new_records:
-            if account.balance < 0:
-                raise ValueError("Account cannot have negative balance")
-    
-    @hook(AFTER_DELETE, model=Account)
-    def after_delete(self, new_records, old_records):
-        print("Accounts deleted:", [a.pk for a in old_records])
+    @hook(AFTER_UPDATE, condition=WhenFieldHasChanged('balance'))
+    def _notify_balance_change(self, new_records, old_records, **kwargs):
+        for new_record, old_record in zip(new_records, old_records):
+            if old_record and new_record.balance != old_record.balance:
+                print(f"Balance changed from {old_record.balance} to {new_record.balance}")
+```
+
+### Bulk Operations with Hooks
+
+```python
+# For complete hook execution, use the update() method
+accounts = Account.objects.filter(active=True)
+accounts.update(balance=1000)  # Runs all hooks automatically
+
+# For bulk operations with hooks
+accounts = Account.objects.filter(active=True)
+instances = list(accounts)
+
+# bulk_update now runs complete hook cycle by default
+accounts.bulk_update(instances, ['balance'])  # Runs VALIDATE → BEFORE → DB update → AFTER
+
+# To skip hooks (for performance or when called from update())
+accounts.bulk_update(instances, ['balance'], bypass_hooks=True)
 ```
 
+### Understanding Hook Execution
+
+- **`update()` method**: Runs complete hook cycle (VALIDATE → BEFORE → DB update → AFTER)
+- **`bulk_update()` method**: Runs complete hook cycle (VALIDATE → BEFORE → DB update → AFTER)
+- **`bypass_hooks=True`**: Skips all hooks for performance or to prevent double execution
+
 ## 🛠 Supported Hook Events
 
 - `BEFORE_CREATE`, `AFTER_CREATE`

{django_bulk_hooks-0.1.225 → django_bulk_hooks-0.1.227}/django_bulk_hooks/engine.py

@@ -10,6 +10,13 @@ logger = logging.getLogger(__name__)
 def run(model_cls, event, new_records, old_records=None, ctx=None):
     """
     Run hooks for a given model, event, and records.
+    
+    Args:
+        model_cls: The Django model class
+        event: The hook event (e.g., 'before_create', 'after_update')
+        new_records: List of new/updated records
+        old_records: List of original records (for comparison)
+        ctx: Optional hook context
     """
     if not new_records:
         return
@@ -20,14 +27,11 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
     if not hooks:
         return
 
-    import traceback
-
-    stack = traceback.format_stack()
-    logger.debug(f"engine.run {model_cls.__name__}.{event} {len(new_records)} records")
+    logger.debug(f"Running {len(hooks)} hooks for {model_cls.__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:
-        logger.debug("engine.run bypassed")
+        logger.debug("Hook execution bypassed")
         return
 
     # For BEFORE_* events, run model.clean() first for validation
@@ -39,11 +43,16 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
                 logger.error("Validation failed for %s: %s", instance, e)
                 raise
 
-    # Process hooks
+    # Process hooks in priority order
     for handler_cls, method_name, condition, priority in hooks:
-        logger.debug(f"Processing {handler_cls.__name__}.{method_name}")
-        handler_instance = handler_cls()
-        func = getattr(handler_instance, method_name)
+        logger.debug(f"Processing {handler_cls.__name__}.{method_name} (priority: {priority})")
+        
+        try:
+            handler_instance = handler_cls()
+            func = getattr(handler_instance, method_name)
+        except Exception as e:
+            logger.error(f"Failed to instantiate {handler_cls.__name__}: {e}")
+            continue
 
         to_process_new = []
         to_process_old = []
@@ -57,10 +66,14 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
                 to_process_new.append(new)
                 to_process_old.append(original)
             else:
-                condition_result = condition.check(new, original)
-                if condition_result:
-                    to_process_new.append(new)
-                    to_process_old.append(original)
+                try:
+                    condition_result = condition.check(new, original)
+                    if condition_result:
+                        to_process_new.append(new)
+                        to_process_old.append(original)
+                except Exception as e:
+                    logger.error(f"Condition check failed for {handler_cls.__name__}.{method_name}: {e}")
+                    continue
 
         if to_process_new:
             logger.debug(f"Executing {handler_cls.__name__}.{method_name} for {len(to_process_new)} records")
@@ -70,5 +83,5 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
                     old_records=to_process_old if any(to_process_old) else None,
                 )
             except Exception as e:
-                logger.debug(f"Hook execution failed: {e}")
+                logger.error(f"Hook execution failed in {handler_cls.__name__}.{method_name}: {e}")
                 raise

{django_bulk_hooks-0.1.225 → django_bulk_hooks-0.1.227}/django_bulk_hooks/handler.py

@@ -65,24 +65,33 @@ Hook = HookContextState()
 
 
 class HookMeta(type):
-    _registered = set()
-
+    """Metaclass that automatically registers hooks when Hook classes are defined."""
+    
     def __new__(mcs, name, bases, namespace):
         cls = super().__new__(mcs, name, bases, namespace)
+        
+        # Register hooks for this class
         for method_name, method in namespace.items():
             if hasattr(method, "hooks_hooks"):
                 for model_cls, event, condition, priority in method.hooks_hooks:
+                    # Create a unique key for this hook registration
                     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)
+                    
+                    # Register the hook
+                    register_hook(
+                        model=model_cls,
+                        event=event,
+                        handler_cls=cls,
+                        method_name=method_name,
+                        condition=condition,
+                        priority=priority,
+                    )
+                    
+                    logger.debug(
+                        f"Registered hook {cls.__name__}.{method_name} "
+                        f"for {model_cls.__name__}.{event} with priority {priority}"
+                    )
+        
         return cls
 
 

{django_bulk_hooks-0.1.225 → django_bulk_hooks-0.1.227}/django_bulk_hooks/models.py

@@ -68,6 +68,7 @@ class HookModelMixin(models.Model):
             logger.debug(f"save() creating new {self.__class__.__name__} instance")
             # For create operations, we don't have old records
             ctx = HookContext(self.__class__)
+            run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
             run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
 
             super().save(*args, **kwargs)
@@ -80,6 +81,7 @@ class HookModelMixin(models.Model):
                 # Use _base_manager to avoid triggering hooks recursively
                 old_instance = self.__class__._base_manager.get(pk=self.pk)
                 ctx = HookContext(self.__class__)
+                run(self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx)
                 run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
 
                 super().save(*args, **kwargs)
@@ -88,6 +90,7 @@ class HookModelMixin(models.Model):
             except self.__class__.DoesNotExist:
                 # If the old instance doesn't exist, treat as create
                 ctx = HookContext(self.__class__)
+                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
                 run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
 
                 super().save(*args, **kwargs)

{django_bulk_hooks-0.1.225 → django_bulk_hooks-0.1.227}/django_bulk_hooks/queryset.py

@@ -1,11 +1,8 @@
 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, Value, When
 from django_bulk_hooks import engine
-
-logger = logging.getLogger(__name__)
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -19,6 +16,8 @@ from django_bulk_hooks.constants import (
 )
 from django_bulk_hooks.context import HookContext
 
+logger = logging.getLogger(__name__)
+
 
 class HookQuerySetMixin:
     """
@@ -28,11 +27,23 @@ class HookQuerySetMixin:
 
     @transaction.atomic
     def delete(self):
+        """
+        Delete objects from the database with complete hook support.
+
+        This method runs the complete hook cycle:
+        VALIDATE_DELETE → BEFORE_DELETE → DB delete → AFTER_DELETE
+        """
         objs = list(self)
         if not objs:
             return 0
 
         model_cls = self.model
+
+        # Validate that all objects have primary keys
+        for obj in objs:
+            if obj.pk is None:
+                raise ValueError("Cannot delete objects without primary keys")
+
         ctx = HookContext(model_cls)
 
         # Run validation hooks first
@@ -51,6 +62,17 @@ class HookQuerySetMixin:
 
     @transaction.atomic
     def update(self, **kwargs):
+        """
+        Update objects with field values and run complete hook cycle.
+        
+        This method runs the complete hook cycle for all updates:
+        VALIDATE_UPDATE → BEFORE_UPDATE → DB update → AFTER_UPDATE
+        
+        Supports both simple field updates and complex expressions (Subquery, Case, etc.).
+        """
+        # Extract custom parameters
+        bypass_hooks = kwargs.pop('bypass_hooks', False)
+        
         instances = list(self)
         if not instances:
             return 0
@@ -58,93 +80,49 @@ 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
+        # Check if any of the update values are complex database expressions
         has_subquery = any(
-            hasattr(value, "query") and hasattr(value, "resolve_expression")
+            (hasattr(value, "query") and hasattr(value.query, "model"))
+            or (hasattr(value, "get_source_expressions") and value.get_source_expressions())
             for value in kwargs.values()
         )
 
-        # 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)
-
-        # If we're in a bulk operation context, skip hooks to prevent double execution
-        if current_bypass_hooks:
-            ctx = HookContext(model_cls, bypass_hooks=True)
-            # For bulk operations without hooks, execute update
-            update_count = super().update(**kwargs)
+        # Run hooks only if not bypassed
+        if not bypass_hooks:
+            # Run VALIDATE_UPDATE hooks
+            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, HookContext(model_cls))
+            
+            # Run BEFORE_UPDATE hooks
+            engine.run(model_cls, BEFORE_UPDATE, instances, originals, HookContext(model_cls))
+
+        if has_subquery:
+            # For complex expressions, use Django's native update
+            # This handles Subquery, Case, F expressions, etc. correctly
+            result = super().update(**kwargs)
         else:
-            ctx = HookContext(model_cls, bypass_hooks=False)
-
-            # 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
-                # Use the model's default manager to ensure queryable properties are properly handled
-                refreshed_instances = {
-                    obj.pk: obj for obj in model_cls.objects.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:
-            engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
-
-        return update_count
+            # For simple field updates, apply changes to instances first
+            for obj in instances:
+                for field, value in kwargs.items():
+                    setattr(obj, field, value)
+
+            # Perform database update using Django's native bulk_update
+            # We use the base manager to avoid recursion
+            base_manager = model_cls._base_manager
+            fields_to_update = list(kwargs.keys())
+            base_manager.bulk_update(instances, fields_to_update)
+            result = len(instances)
+
+        # Run AFTER_UPDATE hooks only if not bypassed
+        if not bypass_hooks:
+            engine.run(model_cls, AFTER_UPDATE, instances, originals, HookContext(model_cls))
+        
+        return result
 
     @transaction.atomic
     def bulk_create(
@@ -159,35 +137,32 @@ class HookQuerySetMixin:
         bypass_validation=False,
     ):
         """
-        Insert each of the instances into the database. Behaves like Django's bulk_create,
-        but supports multi-table inheritance (MTI) models and hooks. All arguments are supported and
-        passed through to the correct logic. For MTI, only a subset of options may be supported.
+        Insert each of the instances into the database with complete hook support.
+
+        This method runs the complete hook cycle:
+        VALIDATE_CREATE → BEFORE_CREATE → DB create → AFTER_CREATE
+
+        Behaves like Django's bulk_create but supports multi-table inheritance (MTI)
+        models and hooks. All arguments are supported and passed through to the correct logic.
         """
         model_cls = self.model
 
-        # When you bulk insert you don't get the primary keys back (if it's an
-        # autoincrement, except if can_return_rows_from_bulk_insert=True), so
-        # you can't insert into the child tables which references this. There
-        # are two workarounds:
-        # 1) This could be implemented if you didn't have an autoincrement pk
-        # 2) You could do it by doing O(n) normal inserts into the parent
-        #    tables to get the primary keys back and then doing a single bulk
-        #    insert into the childmost table.
-        # We currently set the primary keys on the objects when using
-        # PostgreSQL via the RETURNING ID clause. It should be possible for
-        # Oracle as well, but the semantics for extracting the primary keys is
-        # trickier so it's not done yet.
-        if batch_size is not None and batch_size <= 0:
-            raise ValueError("Batch size must be a positive integer.")
+        # Validate inputs
+        if not isinstance(objs, (list, tuple)):
+            raise TypeError("objs must be a list or tuple")
 
         if not objs:
             return objs
 
         if any(not isinstance(obj, model_cls) for obj in objs):
             raise TypeError(
-                f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
+                f"bulk_create expected instances of {model_cls.__name__}, "
+                f"but got {set(type(obj).__name__ for obj in objs)}"
             )
 
+        if batch_size is not None and batch_size <= 0:
+            raise ValueError("batch_size must be a positive integer.")
+
         # Check for MTI - if we detect multi-table inheritance, we need special handling
         # This follows Django's approach: check that the parents share the same concrete model
         # with our model to detect the inheritance pattern ConcreteGrandParent ->
@@ -201,12 +176,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)
             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)
             logger.debug("bulk_create bypassed hooks")
 
         # For MTI models, we need to handle them specially
@@ -250,76 +225,113 @@ class HookQuerySetMixin:
         self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
     ):
         """
-        Bulk update objects in the database with MTI support.
+        Bulk update objects in the database with complete hook support.
+
+        This method always runs the complete hook cycle:
+        VALIDATE_UPDATE → BEFORE_UPDATE → DB update → AFTER_UPDATE
+
+        Args:
+            objs: List of model instances to update
+            fields: List of field names to update
+            bypass_hooks: DEPRECATED - kept for backward compatibility only
+            bypass_validation: DEPRECATED - kept for backward compatibility only
+            **kwargs: Additional arguments passed to Django's bulk_update
         """
         model_cls = self.model
 
         if not objs:
             return []
 
-        if any(not isinstance(obj, model_cls) for obj in objs):
-            raise TypeError(
-                f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
-            )
+        # Validate inputs
+        if not isinstance(objs, (list, tuple)):
+            raise TypeError("objs must be a list or tuple")
 
-        logger.debug(
-            f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}"
-        )
+        if not isinstance(fields, (list, tuple)):
+            raise TypeError("fields must be a list or tuple")
 
-        # Check for MTI
-        is_mti = False
-        for parent in model_cls._meta.all_parents:
-            if parent._meta.concrete_model is not model_cls._meta.concrete_model:
-                is_mti = True
-                break
+        if not objs:
+            return []
+
+        if not fields:
+            raise ValueError("fields cannot be empty")
+
+        # Validate that all objects are instances of the model
+        for obj in objs:
+            if not isinstance(obj, model_cls):
+                raise TypeError(
+                    f"Expected instances of {model_cls.__name__}, got {type(obj).__name__}"
+                )
+            if obj.pk is None:
+                raise ValueError("All objects must have a primary key")
 
+        # Load originals for hook comparison
+        pks = [obj.pk for obj in objs]
+        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 objs]
+
+        # Run VALIDATE_UPDATE hooks
+        if not bypass_validation:
+            engine.run(
+                model_cls, VALIDATE_UPDATE, objs, originals, HookContext(model_cls)
+            )
+
+        # Run BEFORE_UPDATE hooks
         if not bypass_hooks:
-            logger.debug("bulk_update: hooks will run in update()")
-            ctx = HookContext(model_cls, bypass_hooks=False)
-            originals = [None] * len(objs)  # Placeholder for after_update call
-        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
-
-        # Handle auto_now fields like Django's update_or_create does
-        fields_set = set(fields)
-        pk_fields = model_cls._meta.pk_fields
-        for field in model_cls._meta.local_concrete_fields:
-            # Only add auto_now fields (like updated_at) that aren't already in the fields list
-            # Don't include auto_now_add fields (like created_at) as they should only be set on creation
-            if hasattr(field, "auto_now") and field.auto_now:
-                if field.name not in fields_set and field.name not in pk_fields:
-                    fields_set.add(field.name)
-                    if field.name != field.attname:
-                        fields_set.add(field.attname)
-        fields = list(fields_set)
-
-        # Handle MTI models differently
-        if is_mti:
-            result = self._mti_bulk_update(objs, fields, **kwargs)
-        else:
-            # For single-table models, use Django's built-in bulk_update
-            django_kwargs = {
-                k: v
-                for k, v in kwargs.items()
-                if k not in ["bypass_hooks", "bypass_validation"]
-            }
-            logger.debug("Calling Django bulk_update")
-            result = super().bulk_update(objs, fields, **django_kwargs)
-            logger.debug(f"Django bulk_update done: {result}")
+            engine.run(
+                model_cls, BEFORE_UPDATE, objs, originals, HookContext(model_cls)
+            )
+
+        # Perform database update using Django's native bulk_update
+        # We use the base manager to avoid recursion
+        base_manager = model_cls._base_manager
+        result = base_manager.bulk_update(objs, fields, **kwargs)
 
-        # Note: We don't run AFTER_UPDATE hooks here to prevent double execution
-        # The update() method will handle all hook execution based on thread-local state
+        # Run AFTER_UPDATE hooks
         if not bypass_hooks:
-            logger.debug("bulk_update: skipping AFTER_UPDATE (update() will handle)")
-        else:
-            logger.debug("bulk_update: hooks bypassed")
+            engine.run(model_cls, AFTER_UPDATE, objs, originals, HookContext(model_cls))
 
         return result
 
+    @transaction.atomic
+    def bulk_delete(self, objs, **kwargs):
+        """
+        Delete the given objects from the database with complete hook support.
+
+        This method runs the complete hook cycle:
+        VALIDATE_DELETE → BEFORE_DELETE → DB delete → AFTER_DELETE
+
+        This is a convenience method that provides a bulk_delete interface
+        similar to bulk_create and bulk_update.
+        """
+        model_cls = self.model
+
+        # Extract custom kwargs
+        bypass_hooks = kwargs.pop("bypass_hooks", False)
+
+        # Validate inputs
+        if not isinstance(objs, (list, tuple)):
+            raise TypeError("objs must be a list or tuple")
+
+        if not objs:
+            return 0
+
+        # Validate that all objects are instances of the model
+        for obj in objs:
+            if not isinstance(obj, model_cls):
+                raise TypeError(
+                    f"Expected instances of {model_cls.__name__}, got {type(obj).__name__}"
+                )
+
+        # Get the pks to delete
+        pks = [obj.pk for obj in objs if obj.pk is not None]
+        if not pks:
+            return 0
+
+        # Use the delete() method which already has hook support
+        return self.filter(pk__in=pks).delete()
+
     def _detect_modified_fields(self, new_instances, original_instances):
         """
         Detect fields that were modified during BEFORE_UPDATE hooks by comparing

django_bulk_hooks-0.1.227/django_bulk_hooks/registry.py

@@ -0,0 +1,87 @@
+import logging
+from collections.abc import Callable
+from typing import Union
+
+from django_bulk_hooks.priority import Priority
+
+logger = logging.getLogger(__name__)
+
+_hooks: dict[tuple[type, str], list[tuple[type, str, Callable, int]]] = {}
+
+
+def register_hook(
+    model, event, handler_cls, method_name, condition, priority: Union[int, Priority]
+):
+    """
+    Register a hook for a specific model and event.
+    
+    Args:
+        model: The Django model class
+        event: The hook event (e.g., 'before_create', 'after_update')
+        handler_cls: The hook handler class
+        method_name: The method name in the handler class
+        condition: Optional condition for when the hook should run
+        priority: Hook execution priority (higher numbers execute first)
+    """
+    if not model or not event or not handler_cls or not method_name:
+        logger.warning("Invalid hook registration parameters")
+        return
+    
+    key = (model, event)
+    hooks = _hooks.setdefault(key, [])
+    
+    # Check for duplicate registrations
+    existing = [h for h in hooks if h[0] == handler_cls and h[1] == method_name]
+    if existing:
+        logger.warning(
+            f"Hook {handler_cls.__name__}.{method_name} already registered "
+            f"for {model.__name__}.{event}"
+        )
+        return
+    
+    # Add the hook
+    hooks.append((handler_cls, method_name, condition, priority))
+    
+    # Sort by priority (lowest numbers execute first, matching engine expectation)
+    hooks.sort(key=lambda x: x[3])
+    
+    logger.debug(
+        f"Registered {handler_cls.__name__}.{method_name} "
+        f"for {model.__name__}.{event} with priority {priority}"
+    )
+
+
+def get_hooks(model, event):
+    """
+    Get all registered hooks for a specific model and event.
+    
+    Args:
+        model: The Django model class
+        event: The hook event
+        
+    Returns:
+        List of (handler_cls, method_name, condition, priority) tuples
+    """
+    if not model or not event:
+        return []
+    
+    key = (model, event)
+    hooks = _hooks.get(key, [])
+    
+    # Log hook discovery for debugging
+    if hooks:
+        logger.debug(f"Found {len(hooks)} hooks for {model.__name__}.{event}")
+    
+    return hooks
+
+
+def list_all_hooks():
+    """Debug function to list all registered hooks."""
+    return _hooks
+
+
+def clear_hooks():
+    """Clear all registered hooks (mainly for testing)."""
+    global _hooks
+    _hooks.clear()
+    logger.debug("All hooks cleared")

{django_bulk_hooks-0.1.225 → django_bulk_hooks-0.1.227}/pyproject.toml

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

django_bulk_hooks-0.1.225/django_bulk_hooks/registry.py

@@ -1,34 +0,0 @@
-import logging
-from collections.abc import Callable
-from typing import Union
-
-from django_bulk_hooks.priority import Priority
-
-logger = logging.getLogger(__name__)
-
-_hooks: dict[tuple[type, str], list[tuple[type, str, Callable, int]]] = {}
-
-
-def register_hook(
-    model, event, handler_cls, method_name, condition, priority: Union[int, Priority]
-):
-    key = (model, event)
-    hooks = _hooks.setdefault(key, [])
-    hooks.append((handler_cls, method_name, condition, priority))
-    # keep sorted by priority
-    hooks.sort(key=lambda x: x[3])
-    logger.debug(f"Registered {handler_cls.__name__}.{method_name} for {model.__name__}.{event}")
-
-
-def get_hooks(model, event):
-    key = (model, event)
-    hooks = _hooks.get(key, [])
-    # Only log when hooks are found or for specific events to reduce noise
-    if hooks or event in ['after_update', 'before_update', 'after_create', 'before_create']:
-        logger.debug(f"get_hooks {model.__name__}.{event} found {len(hooks)} hooks")
-    return hooks
-
-
-def list_all_hooks():
-    """Debug function to list all registered hooks"""
-    return _hooks