django-bulk-hooks 0.1.226__tar.gz → 0.1.228__tar.gz

{django_bulk_hooks-0.1.226 → django_bulk_hooks-0.1.228}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.226
+Version: 0.1.228
 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.226 → django_bulk_hooks-0.1.228}/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.226 → django_bulk_hooks-0.1.228}/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,17 @@ 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 (highest priority first)
+    # Registry now sorts by priority (highest first)
     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,18 +67,23 @@ 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")
             try:
                 func(
                     new_records=to_process_new,
-                    old_records=to_process_old if any(to_process_old) else None,
+                    old_records=to_process_old if any(x is not None for x in 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}")
+                # Re-raise the exception to ensure proper error handling
                 raise

django_bulk_hooks-0.1.228/django_bulk_hooks/enums.py

@@ -0,0 +1,3 @@
+from django_bulk_hooks.priority import Priority
+
+DEFAULT_PRIORITY = Priority.NORMAL

{django_bulk_hooks-0.1.226 → django_bulk_hooks-0.1.228}/django_bulk_hooks/handler.py

@@ -61,28 +61,44 @@ class HookContextState:
         return hook_vars.model
 
 
-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)
-        for method_name, method in namespace.items():
-            if hasattr(method, "hooks_hooks"):
-                for model_cls, event, condition, priority in method.hooks_hooks:
-                    key = (model_cls, event, cls, method_name)
-                    if key not in HookMeta._registered:
+        
+        # Register hooks for this class, including inherited methods
+        # We need to check all methods in the MRO to handle inheritance
+        for attr_name in dir(cls):
+            if attr_name.startswith('_'):
+                continue
+                
+            try:
+                attr = getattr(cls, attr_name)
+                if callable(attr) and hasattr(attr, "hooks_hooks"):
+                    for model_cls, event, condition, priority in attr.hooks_hooks:
+                        # Create a unique key for this hook registration
+                        key = (model_cls, event, cls, attr_name)
+                        
+                        # Register the hook
                         register_hook(
                             model=model_cls,
                             event=event,
                             handler_cls=cls,
-                            method_name=method_name,
+                            method_name=attr_name,
                             condition=condition,
                             priority=priority,
                         )
-                        HookMeta._registered.add(key)
+                        
+                        logger.debug(
+                            f"Registered hook {cls.__name__}.{attr_name} "
+                            f"for {model_cls.__name__}.{event} with priority {priority}"
+                        )
+            except Exception as e:
+                # Skip attributes that can't be accessed
+                logger.debug(f"Skipping attribute {attr_name}: {e}")
+                continue
+        
         return cls
 
 
@@ -123,7 +139,7 @@ class Hook(metaclass=HookMeta):
         hook_vars.event = event
         hook_vars.model = model
 
-        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
+        hooks = get_hooks(model, event)
 
         def _execute():
             new_local = new_records or []
@@ -152,6 +168,8 @@ class Hook(metaclass=HookMeta):
                     logger.exception(
                         "Error in hook %s.%s", handler_cls.__name__, method_name
                     )
+                    # Re-raise the exception to ensure proper error handling
+                    raise
 
         conn = transaction.get_connection()
         try:
@@ -165,3 +183,7 @@ class Hook(metaclass=HookMeta):
             hook_vars.event = None
             hook_vars.model = None
             hook_vars.depth -= 1
+
+
+# Create a global Hook instance for context access
+HookContext = HookContextState()

django_bulk_hooks-0.1.228/django_bulk_hooks/priority.py

@@ -0,0 +1,16 @@
+from enum import IntEnum
+
+
+class Priority(IntEnum):
+    """
+    Named priorities for django-bulk-hooks hooks.
+
+    Higher values run earlier (higher priority).
+    Hooks are sorted in descending order.
+    """
+
+    LOWEST = 0  # runs last
+    LOW = 25  # runs later
+    NORMAL = 50  # default ordering
+    HIGH = 75  # runs early
+    HIGHEST = 100  # runs first

{django_bulk_hooks-0.1.226 → django_bulk_hooks-0.1.228}/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,109 +80,77 @@ 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 complex database expressions (Subquery, Case, etc.)
+        # Check if any of the update values are complex database expressions
         has_subquery = any(
-            (hasattr(value, "query") and hasattr(value, "resolve_expression"))
-            or hasattr(
-                value, "resolve_expression"
-            )  # This catches Case, F expressions, etc.
+            (hasattr(value, "query") and hasattr(value.query, "model"))
+            or (hasattr(value, "get_source_expressions") and value.get_source_expressions())
             for value in kwargs.values()
         )
-        
-        # Also check if any of the instances have complex expressions in their attributes
-        # This can happen when bulk_update creates Case expressions and applies them to instances
-        if not has_subquery and instances:
-            for instance in instances:
-                for field_name in kwargs.keys():
-                    if hasattr(instance, field_name):
-                        field_value = getattr(instance, field_name)
-                        if hasattr(field_value, "resolve_expression"):
-                            has_subquery = True
-                            break
-                if has_subquery:
-                    break
-
-        # 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)
-        else:
-            ctx = HookContext(model_cls, bypass_hooks=False)
 
-            # For subquery cases, we need special handling
+        # Run hooks only if not bypassed
+        if not bypass_hooks:
+            ctx = HookContext(model_cls)
+            # Run VALIDATE_UPDATE hooks
+            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
+            
+            # For subqueries, we need to compute the values and apply them to instances
+            # before running BEFORE_UPDATE hooks
             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, AttributeError) as e:
-                    # If validation fails due to Subquery/Case comparison, skip validation for complex updates
-                    # This is a limitation - validation hooks cannot easily work with unresolved database expressions
-                    logger.warning(
-                        f"Skipping validation hooks for complex 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)
+                # Create a temporary update to compute the values
+                # We'll use a subquery to compute values without actually updating
+                for field_name, value in kwargs.items():
+                    if (hasattr(value, "query") and hasattr(value.query, "model")) or \
+                       (hasattr(value, "get_source_expressions") and value.get_source_expressions()):
+                        # This is a complex expression - compute it for each instance
+                        for instance in instances:
+                            # Create a single-instance queryset to compute the value
+                            single_qs = model_cls._base_manager.filter(pk=instance.pk)
+                            computed_values = single_qs.annotate(computed_field=value).values_list('computed_field', flat=True)
+                            if computed_values:
+                                setattr(instance, field_name, computed_values[0])
             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:
+                # For simple updates, apply the values directly
+                for obj in instances:
+                    for field, value in kwargs.items():
+                        setattr(obj, field, value)
+            
+            # Run BEFORE_UPDATE hooks with updated instances
+            engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
+
+        if has_subquery:
+            # For complex expressions, use Django's native update
+            # This handles Subquery, Case, F expressions, etc. correctly
+            result = super().update(**kwargs)
+            
+            # After updating with complex expressions, we need to reload the instances
+            # to get the computed values for the AFTER_UPDATE hooks
+            if not bypass_hooks:
+                # Reload instances to get computed values
+                updated_instances = list(model_cls._base_manager.filter(pk__in=pks))
+                # Maintain the original order
+                updated_map = {obj.pk: obj for obj in updated_instances}
+                instances = [updated_map.get(obj.pk, obj) for obj in instances]
+        else:
+            # For simple field updates, instances have already been updated in the hook section
+            # 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:
+            ctx = HookContext(model_cls)
             engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
-
-        return update_count
+        
+        return result
 
     @transaction.atomic
     def bulk_create(
@@ -175,35 +165,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 ->
@@ -217,12 +204,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
@@ -266,76 +253,116 @@ 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:
+            ctx = HookContext(model_cls)
+            engine.run(
+                model_cls, VALIDATE_UPDATE, objs, originals, ctx=ctx
+            )
+
+        # 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}")
+            ctx = HookContext(model_cls)
+            engine.run(
+                model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx
+            )
+
+        # 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")
+            ctx = HookContext(model_cls)
+            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
 
         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.228/django_bulk_hooks/registry.py

@@ -0,0 +1,91 @@
+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 (highest numbers execute first)
+    hooks.sort(key=lambda x: x[3], reverse=True)
+    
+    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}")
+        for handler_cls, method_name, condition, priority in hooks:
+            logger.debug(f"  - {handler_cls.__name__}.{method_name} (priority: {priority})")
+    else:
+        logger.debug(f"No hooks found 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.226 → django_bulk_hooks-0.1.228}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.226"
+version = "0.1.228"
 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.226/django_bulk_hooks/enums.py

@@ -1,17 +0,0 @@
-from enum import IntEnum
-
-
-class Priority(IntEnum):
-    """
-    Named priorities for django-bulk-hooks hooks.
-    Replaces module-level constants with a clean IntEnum.
-    """
-
-    HIGHEST = 0  # runs first
-    HIGH = 25  # runs early
-    NORMAL = 50  # default ordering
-    LOW = 75  # runs late
-    LOWEST = 100  # runs last
-
-
-DEFAULT_PRIORITY = Priority.NORMAL

django_bulk_hooks-0.1.226/django_bulk_hooks/priority.py

@@ -1,16 +0,0 @@
-from enum import IntEnum
-
-
-class Priority(IntEnum):
-    """
-    Named priorities for django-bulk-hooks hooks.
-
-    Lower values run earlier (higher priority).
-    Hooks are sorted in ascending order.
-    """
-
-    HIGHEST = 0  # runs first
-    HIGH = 25  # runs early
-    NORMAL = 50  # default ordering
-    LOW = 75  # runs later
-    LOWEST = 100  # runs last

django_bulk_hooks-0.1.226/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