django-bulk-hooks 0.1.101__py3-none-any.whl → 0.1.103__py3-none-any.whl

django_bulk_hooks/engine.py

@@ -1,19 +1,13 @@
 import logging
 
 from django.core.exceptions import ValidationError
-from django.db import models
+
 from django_bulk_hooks.registry import get_hooks
-from django_bulk_hooks.conditions import safe_get_related_object, safe_get_related_attr
 
 logger = logging.getLogger(__name__)
 
 
-# Cache for hook handlers to avoid creating them repeatedly
-_handler_cache = {}
-
 def run(model_cls, event, new_instances, original_instances=None, ctx=None):
-    # Get hooks from cache or fetch them
-    cache_key = (model_cls, event)
     hooks = get_hooks(model_cls, event)
 
     if not hooks:
@@ -27,112 +21,23 @@ def run(model_cls, event, new_instances, original_instances=None, ctx=None):
             except ValidationError as e:
                 logger.error("Validation failed for %s: %s", instance, e)
                 raise
-            except Exception as e:
-                # Handle RelatedObjectDoesNotExist and other exceptions that might occur
-                # when accessing foreign key fields on unsaved objects
-                if "RelatedObjectDoesNotExist" in str(type(e).__name__):
-                    logger.debug("Skipping validation for unsaved object with unset foreign keys: %s", e)
-                    continue
-                else:
-                    logger.error("Unexpected error during validation for %s: %s", instance, e)
-                    raise
-
-    # Pre-create None list for originals if needed
-    if original_instances is None:
-        original_instances = [None] * len(new_instances)
-
-    # Process all hooks
-    for handler_cls, method_name, condition, priority, select_related_fields in hooks:
-        # Get or create handler instance from cache
-        handler_key = (handler_cls, method_name)
-        if handler_key not in _handler_cache:
-            handler_instance = handler_cls()
-            func = getattr(handler_instance, method_name)
-            _handler_cache[handler_key] = (handler_instance, func)
-        else:
-            handler_instance, func = _handler_cache[handler_key]
-
-        # Apply select_related if specified
-        if select_related_fields:
-            new_instances_with_related = _apply_select_related(new_instances, select_related_fields)
-        else:
-            new_instances_with_related = new_instances
-
-        # Filter instances based on condition
-        if condition:
-            to_process_new = []
-            to_process_old = []
-
-            logger.debug(f"Checking condition {condition.__class__.__name__} for {len(new_instances)} instances")
-            for new, original in zip(new_instances_with_related, original_instances, strict=True):
-                logger.debug(f"Checking instance {new.__class__.__name__}(pk={new.pk})")
-                try:
-                    matches = condition.check(new, original)
-                    logger.debug(f"Condition check result: {matches}")
-                    if matches:
-                        to_process_new.append(new)
-                        to_process_old.append(original)
-                except Exception as e:
-                    logger.error(f"Error checking condition: {e}")
-                    raise
-
-            # Only call if we have matching instances
-            if to_process_new:
-                logger.debug(f"Running hook for {len(to_process_new)} matching instances")
-                func(new_records=to_process_new, old_records=to_process_old if any(to_process_old) else None)
-            else:
-                logger.debug("No instances matched condition")
-        else:
-            # No condition, process all instances
-            logger.debug("No condition, processing all instances")
-            func(new_records=new_instances_with_related, old_records=original_instances if any(original_instances) else None)
-
-
-def _apply_select_related(instances, related_fields):
-    """
-    Apply select_related to instances to prevent queries in loops.
-    This function bulk loads related objects and caches them on the instances.
-    """
-    if not instances:
-        return instances
-
-    # Separate instances with and without PKs
-    instances_with_pk = [obj for obj in instances if obj.pk is not None]
-    instances_without_pk = [obj for obj in instances if obj.pk is None]
-
-    # Bulk load related objects for instances with PKs
-    if instances_with_pk:
-        model_cls = instances_with_pk[0].__class__
-        pks = [obj.pk for obj in instances_with_pk]
-        
-        # Bulk fetch with select_related
-        fetched_instances = model_cls.objects.select_related(*related_fields).in_bulk(pks)
-        
-        # Apply cached related objects to original instances
-        for obj in instances_with_pk:
-            fetched_obj = fetched_instances.get(obj.pk)
-            if fetched_obj:
-                for field in related_fields:
-                    if field not in obj._state.fields_cache:
-                        try:
-                            rel_obj = getattr(fetched_obj, field)
-                            setattr(obj, field, rel_obj)
-                            obj._state.fields_cache[field] = rel_obj
-                        except AttributeError:
-                            pass
-
-    # Handle instances without PKs (e.g., BEFORE_CREATE)
-    for obj in instances_without_pk:
-        for field in related_fields:
-            # Check if the foreign key field is set
-            fk_field_name = f"{field}_id"
-            if hasattr(obj, fk_field_name) and getattr(obj, fk_field_name) is not None:
-                # The foreign key ID is set, so we can try to get the related object safely
-                rel_obj = safe_get_related_object(obj, field)
-                if rel_obj is not None:
-                    # Ensure it's cached to prevent future queries
-                    if not hasattr(obj._state, 'fields_cache'):
-                        obj._state.fields_cache = {}
-                    obj._state.fields_cache[field] = rel_obj
 
-    return instances
+    for handler_cls, method_name, condition, priority in hooks:
+        handler_instance = handler_cls()
+        func = getattr(handler_instance, method_name)
+
+        to_process_new = []
+        to_process_old = []
+
+        for new, original in zip(
+            new_instances,
+            original_instances or [None] * len(new_instances),
+            strict=True,
+        ):
+            if not condition or condition.check(new, original):
+                to_process_new.append(new)
+                to_process_old.append(original)
+
+        if to_process_new:
+            # Call the function with keyword arguments
+            func(new_records=to_process_new, old_records=to_process_old if any(to_process_old) else None)

django_bulk_hooks/handler.py

@@ -1,4 +1,3 @@
-import inspect
 import logging
 import threading
 from collections import deque
@@ -75,11 +74,6 @@ class HookMeta(type):
                 for model_cls, event, condition, priority in method.hooks_hooks:
                     key = (model_cls, event, cls, method_name)
                     if key not in HookMeta._registered:
-                        # Check if the method has been decorated with select_related
-                        select_related_fields = getattr(
-                            method, "_select_related_fields", None
-                        )
-
                         register_hook(
                             model=model_cls,
                             event=event,
@@ -87,13 +81,12 @@ class HookMeta(type):
                             method_name=method_name,
                             condition=condition,
                             priority=priority,
-                            select_related_fields=select_related_fields,
                         )
                         HookMeta._registered.add(key)
         return cls
 
 
-class HookHandler(metaclass=HookMeta):
+class Hook(metaclass=HookMeta):
     @classmethod
     def handle(
         cls,
@@ -138,17 +131,10 @@ class HookHandler(metaclass=HookMeta):
             if len(old_local) < len(new_local):
                 old_local += [None] * (len(new_local) - len(old_local))
 
-            for handler_cls, method_name, condition, priority, select_related_fields in hooks:
-                # Apply select_related if specified to prevent queries in loops
-                if select_related_fields:
-                    from django_bulk_hooks.engine import _apply_select_related
-                    new_local_with_related = _apply_select_related(new_local, select_related_fields)
-                else:
-                    new_local_with_related = new_local
-
+            for handler_cls, method_name, condition, priority in hooks:
                 if condition is not None:
                     checks = [
-                        condition.check(n, o) for n, o in zip(new_local_with_related, old_local)
+                        condition.check(n, o) for n, o in zip(new_local, old_local)
                     ]
                     if not any(checks):
                         continue
@@ -156,21 +142,10 @@ class HookHandler(metaclass=HookMeta):
                 handler = handler_cls()
                 method = getattr(handler, method_name)
 
-                # Inspect the method signature to determine parameter order
-                import inspect
-
-                sig = inspect.signature(method)
-                params = list(sig.parameters.keys())
-
-                # Remove 'self' from params if it exists
-                if params and params[0] == "self":
-                    params = params[1:]
-
-                # Always call with keyword arguments to make order irrelevant
                 try:
                     method(
+                        new_records=new_local,
                         old_records=old_local,
-                        new_records=new_local_with_related,
                         **kwargs,
                     )
                 except Exception:

django_bulk_hooks/manager.py

@@ -17,82 +17,15 @@ from django_bulk_hooks.queryset import HookQuerySet
 
 
 class BulkHookManager(models.Manager):
-    # Default chunk sizes - can be overridden per model
-    DEFAULT_CHUNK_SIZE = 200
-    DEFAULT_RELATED_CHUNK_SIZE = 500  # Higher for related object fetching
-    
-    def __init__(self):
-        super().__init__()
-        self._chunk_size = self.DEFAULT_CHUNK_SIZE
-        self._related_chunk_size = self.DEFAULT_RELATED_CHUNK_SIZE
-        self._prefetch_related_fields = set()
-        self._select_related_fields = set()
-
-    def configure(self, chunk_size=None, related_chunk_size=None, 
-                 select_related=None, prefetch_related=None):
-        """
-        Configure bulk operation parameters for this manager.
-        
-        Args:
-            chunk_size: Number of objects to process in each bulk operation chunk
-            related_chunk_size: Number of objects to fetch in each related object query
-            select_related: List of fields to always select_related in bulk operations
-            prefetch_related: List of fields to always prefetch_related in bulk operations
-        """
-        if chunk_size is not None:
-            self._chunk_size = chunk_size
-        if related_chunk_size is not None:
-            self._related_chunk_size = related_chunk_size
-        if select_related:
-            self._select_related_fields.update(select_related)
-        if prefetch_related:
-            self._prefetch_related_fields.update(prefetch_related)
-
-    def _load_originals_optimized(self, pks, fields_to_fetch=None):
-        """
-        Optimized loading of original instances with smart batching and field selection.
-        """
-        queryset = self.model.objects.filter(pk__in=pks)
-        
-        # Only select specific fields if provided
-        if fields_to_fetch:
-            queryset = queryset.only('pk', *fields_to_fetch)
-            
-        # Apply configured related field optimizations
-        if self._select_related_fields:
-            queryset = queryset.select_related(*self._select_related_fields)
-        if self._prefetch_related_fields:
-            queryset = queryset.prefetch_related(*self._prefetch_related_fields)
-            
-        # Batch load in chunks to avoid memory issues
-        all_originals = []
-        for i in range(0, len(pks), self._related_chunk_size):
-            chunk_pks = pks[i:i + self._related_chunk_size]
-            chunk_originals = list(queryset.filter(pk__in=chunk_pks))
-            all_originals.extend(chunk_originals)
-            
-        return all_originals
-
-    def _get_fields_to_fetch(self, objs, fields):
-        """
-        Determine which fields need to be fetched based on what's being updated
-        and what's needed for hooks.
-        """
-        fields_to_fetch = set(fields)
-        
-        # Add fields needed by registered hooks
-        from django_bulk_hooks.registry import get_hooks
-        hooks = get_hooks(self.model, "before_update") + get_hooks(self.model, "after_update")
-        
-        for handler_cls, method_name, condition, _ in hooks:
-            if condition:
-                # If there's a condition, we need all fields it might access
-                fields_to_fetch.update(condition.get_required_fields())
-                
-        return fields_to_fetch
+    CHUNK_SIZE = 200
+
+    def get_queryset(self):
+        return HookQuerySet(self.model, using=self._db)
 
     @transaction.atomic
-    def bulk_update(self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs):
+    def bulk_update(
+        self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
+    ):
         if not objs:
             return []
 
@@ -104,42 +37,36 @@ class BulkHookManager(models.Manager):
             )
 
         if not bypass_hooks:
-            # Determine which fields we need to fetch
-            fields_to_fetch = self._get_fields_to_fetch(objs, fields)
-            
-            # Load originals efficiently
-            pks = [obj.pk for obj in objs if obj.pk is not None]
-            originals = self._load_originals_optimized(pks, fields_to_fetch)
-            
-            # Create a mapping for quick lookup
-            original_map = {obj.pk: obj for obj in originals}
-            
-            # Align originals with new instances
-            aligned_originals = [original_map.get(obj.pk) for obj in objs]
+            # Load originals for hook comparison and ensure they match the order of new instances
+            original_map = {
+                obj.pk: obj for obj in model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
+            }
+            originals = [original_map.get(obj.pk) for obj in objs]
 
             ctx = HookContext(model_cls)
 
             # Run validation hooks first
             if not bypass_validation:
-                engine.run(model_cls, VALIDATE_UPDATE, objs, aligned_originals, ctx=ctx)
+                engine.run(model_cls, VALIDATE_UPDATE, objs, originals, ctx=ctx)
 
             # Then run business logic hooks
-            engine.run(model_cls, BEFORE_UPDATE, objs, aligned_originals, ctx=ctx)
+            engine.run(model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx)
 
             # Automatically detect fields that were modified during BEFORE_UPDATE hooks
-            modified_fields = self._detect_modified_fields(objs, aligned_originals)
+            modified_fields = self._detect_modified_fields(objs, originals)
             if modified_fields:
+                # Convert to set for efficient union operation
                 fields_set = set(fields)
                 fields_set.update(modified_fields)
                 fields = list(fields_set)
 
-        # Process in chunks
-        for i in range(0, len(objs), self._chunk_size):
-            chunk = objs[i:i + self._chunk_size]
+        for i in range(0, len(objs), self.CHUNK_SIZE):
+            chunk = objs[i : i + self.CHUNK_SIZE]
+            # Call the base implementation to avoid re-triggering this method
             super(models.Manager, self).bulk_update(chunk, fields, **kwargs)
 
         if not bypass_hooks:
-            engine.run(model_cls, AFTER_UPDATE, objs, aligned_originals, ctx=ctx)
+            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
 
         return objs
 
@@ -151,17 +78,11 @@ class BulkHookManager(models.Manager):
         if not original_instances:
             return set()
 
-        # Create a mapping of pk to original instance for efficient lookup
-        original_map = {obj.pk: obj for obj in original_instances if obj.pk is not None}
-
         modified_fields = set()
 
-        for new_instance in new_instances:
-            if new_instance.pk is None:
-                continue
-
-            original = original_map.get(new_instance.pk)
-            if not original:
+        # Since original_instances is now ordered to match new_instances, we can zip them directly
+        for new_instance, original in zip(new_instances, original_instances):
+            if new_instance.pk is None or original is None:
                 continue
 
             # Compare all fields to detect changes
@@ -188,52 +109,42 @@ class BulkHookManager(models.Manager):
 
     @transaction.atomic
     def bulk_create(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
-        if not objs:
-            return []
-
         model_cls = self.model
-        result = []
 
         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)}"
             )
 
+        result = []
+
         if not bypass_hooks:
             ctx = HookContext(model_cls)
 
-            # Process validation in chunks to avoid memory issues
+            # Run validation hooks first
             if not bypass_validation:
-                for i in range(0, len(objs), self._chunk_size):
-                    chunk = objs[i:i + self._chunk_size]
-                    engine.run(model_cls, VALIDATE_CREATE, chunk, ctx=ctx)
+                engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
 
-            # Process before_create hooks in chunks
-            for i in range(0, len(objs), self._chunk_size):
-                chunk = objs[i:i + self._chunk_size]
-                engine.run(model_cls, BEFORE_CREATE, chunk, ctx=ctx)
+            # Then run business logic hooks
+            engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
 
-        # Perform bulk create in chunks
-        for i in range(0, len(objs), self._chunk_size):
-            chunk = objs[i:i + self._chunk_size]
-            created_chunk = super(models.Manager, self).bulk_create(chunk, **kwargs)
-            result.extend(created_chunk)
+        for i in range(0, len(objs), self.CHUNK_SIZE):
+            chunk = objs[i : i + self.CHUNK_SIZE]
+            result.extend(super(models.Manager, self).bulk_create(chunk, **kwargs))
 
         if not bypass_hooks:
-            # Process after_create hooks in chunks
-            for i in range(0, len(result), self._chunk_size):
-                chunk = result[i:i + self._chunk_size]
-                engine.run(model_cls, AFTER_CREATE, chunk, ctx=ctx)
+            engine.run(model_cls, AFTER_CREATE, result, ctx=ctx)
 
         return result
 
     @transaction.atomic
-    def bulk_delete(self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False):
+    def bulk_delete(
+        self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False
+    ):
         if not objs:
             return []
 
         model_cls = self.model
-        chunk_size = batch_size or self._chunk_size
 
         if any(not isinstance(obj, model_cls) for obj in objs):
             raise TypeError(
@@ -243,25 +154,21 @@ class BulkHookManager(models.Manager):
         ctx = HookContext(model_cls)
 
         if not bypass_hooks:
-            # Process hooks in chunks
-            for i in range(0, len(objs), chunk_size):
-                chunk = objs[i:i + chunk_size]
-                
-                if not bypass_validation:
-                    engine.run(model_cls, VALIDATE_DELETE, chunk, ctx=ctx)
-                engine.run(model_cls, BEFORE_DELETE, chunk, ctx=ctx)
-
-        # Collect PKs and delete in chunks
+            # Run validation hooks first
+            if not bypass_validation:
+                engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
+
+            # Then run business logic hooks
+            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
+
         pks = [obj.pk for obj in objs if obj.pk is not None]
-        for i in range(0, len(pks), chunk_size):
-            chunk_pks = pks[i:i + chunk_size]
-            model_cls._base_manager.filter(pk__in=chunk_pks).delete()
+        
+        # Use base manager for the actual deletion to prevent recursion
+        # The hooks have already been fired above, so we don't need them again
+        model_cls._base_manager.filter(pk__in=pks).delete()
 
         if not bypass_hooks:
-            # Process after_delete hooks in chunks
-            for i in range(0, len(objs), chunk_size):
-                chunk = objs[i:i + chunk_size]
-                engine.run(model_cls, AFTER_DELETE, chunk, ctx=ctx)
+            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
 
         return objs
 

django_bulk_hooks/models.py

@@ -1,8 +1,4 @@
-import contextlib
-from functools import wraps
-
 from django.db import models, transaction
-from django.db.models.fields.related_descriptors import ForwardManyToOneDescriptor
 
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
@@ -20,32 +16,6 @@ from django_bulk_hooks.engine import run
 from django_bulk_hooks.manager import BulkHookManager
 
 
-@contextlib.contextmanager
-def patch_foreign_key_behavior():
-    """
-    Temporarily patches Django's foreign key descriptor to return None instead of raising
-    RelatedObjectDoesNotExist when accessing an unset foreign key field.
-    """
-    original_get = ForwardManyToOneDescriptor.__get__
-
-    @wraps(original_get)
-    def safe_get(self, instance, cls=None):
-        if instance is None:
-            return self
-        try:
-            return original_get(self, instance, cls)
-        except self.RelatedObjectDoesNotExist:
-            return None
-
-    # Patch the descriptor
-    ForwardManyToOneDescriptor.__get__ = safe_get
-    try:
-        yield
-    finally:
-        # Restore original behavior
-        ForwardManyToOneDescriptor.__get__ = original_get
-
-
 class HookModelMixin(models.Model):
     objects = BulkHookManager()
 
@@ -58,88 +28,68 @@ class HookModelMixin(models.Model):
         This ensures that when Django calls clean() (like in admin forms),
         it triggers the VALIDATE_* hooks for validation only.
         """
-        # Call Django's clean first
         super().clean()
 
-        # Skip hook validation during admin form validation
-        # This prevents RelatedObjectDoesNotExist errors when Django hasn't
-        # fully set up the object's relationships yet
-        if hasattr(self, "_state") and getattr(self._state, "validating", False):
-            return
-
         # Determine if this is a create or update operation
         is_create = self.pk is None
 
         if is_create:
             # For create operations, run VALIDATE_CREATE hooks for validation
             ctx = HookContext(self.__class__)
-            with patch_foreign_key_behavior():
-                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
+            run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
         else:
             # For update operations, run VALIDATE_UPDATE hooks for validation
             try:
                 old_instance = self.__class__.objects.get(pk=self.pk)
                 ctx = HookContext(self.__class__)
-                with patch_foreign_key_behavior():
-                    run(
-                        self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx
-                    )
+                run(self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx)
             except self.__class__.DoesNotExist:
                 # If the old instance doesn't exist, treat as create
                 ctx = HookContext(self.__class__)
-                with patch_foreign_key_behavior():
-                    run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
+                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
 
     def save(self, *args, **kwargs):
         is_create = self.pk is None
-        ctx = HookContext(self.__class__)
 
-        # Run BEFORE hooks before saving to allow field modifications
-        with patch_foreign_key_behavior():
-            if is_create:
-                # For create operations
-                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
+        if is_create:
+            # For create operations, we don't have old records
+            ctx = HookContext(self.__class__)
+            run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
+
+            super().save(*args, **kwargs)
+
+            run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
+        else:
+            # For update operations, we need to get the old record
+            try:
+                old_instance = self.__class__.objects.get(pk=self.pk)
+                ctx = HookContext(self.__class__)
+                run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
+
+                super().save(*args, **kwargs)
+
+                run(self.__class__, AFTER_UPDATE, [self], [old_instance], ctx=ctx)
+            except self.__class__.DoesNotExist:
+                # If the old instance doesn't exist, treat as create
+                ctx = HookContext(self.__class__)
                 run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-            else:
-                # For update operations
-                try:
-                    old_instance = self.__class__.objects.get(pk=self.pk)
-                    run(
-                        self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx
-                    )
-                    run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
-                except self.__class__.DoesNotExist:
-                    # If the old instance doesn't exist, treat as create
-                    run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
-                    run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-
-        # Now let Django save with any modifications from BEFORE hooks
-        super().save(*args, **kwargs)
-
-        # Then run AFTER hooks
-        with patch_foreign_key_behavior():
-            if is_create:
-                # For create operations
+
+                super().save(*args, **kwargs)
+
                 run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
-            else:
-                # For update operations
-                try:
-                    old_instance = self.__class__.objects.get(pk=self.pk)
-                    run(self.__class__, AFTER_UPDATE, [self], [old_instance], ctx=ctx)
-                except self.__class__.DoesNotExist:
-                    # If the old instance doesn't exist, treat as create
-                    run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
 
         return self
 
     def delete(self, *args, **kwargs):
         ctx = HookContext(self.__class__)
 
-        # Use a single context manager for all hooks
-        with patch_foreign_key_behavior():
-            run(self.__class__, VALIDATE_DELETE, [self], ctx=ctx)
-            run(self.__class__, BEFORE_DELETE, [self], ctx=ctx)
-            result = super().delete(*args, **kwargs)
-            run(self.__class__, AFTER_DELETE, [self], ctx=ctx)
+        # Run validation hooks first
+        run(self.__class__, VALIDATE_DELETE, [self], ctx=ctx)
+
+        # Then run business logic hooks
+        run(self.__class__, BEFORE_DELETE, [self], ctx=ctx)
+
+        result = super().delete(*args, **kwargs)
 
+        run(self.__class__, AFTER_DELETE, [self], ctx=ctx)
         return result

django_bulk_hooks/priority.py

@@ -0,0 +1,16 @@
+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