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

django_bulk_hooks/manager.py

@@ -17,113 +17,10 @@ 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 and not empty
-        if fields_to_fetch and len(fields_to_fetch) > 0:
-            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)
+    CHUNK_SIZE = 200
 
-        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())
-
-        # Filter out fields that don't exist on the model
-        valid_fields = set()
-        invalid_fields = set()
-        for field_name in fields_to_fetch:
-            try:
-                self.model._meta.get_field(field_name)
-                valid_fields.add(field_name)
-            except Exception as e:
-                # Field doesn't exist, skip it
-                invalid_fields.add(field_name)
-                import logging
-
-                logger = logging.getLogger(__name__)
-                logger.debug(
-                    f"Field '{field_name}' requested by hook condition but doesn't exist on {self.model.__name__}: {e}"
-                )
-                continue
-
-        if invalid_fields:
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.warning(
-                f"Invalid fields requested for {self.model.__name__}: {invalid_fields}. "
-                f"These fields were ignored to prevent errors."
-            )
-
-        return valid_fields
+    def get_queryset(self):
+        return HookQuerySet(self.model, using=self._db)
 
     @transaction.atomic
     def bulk_update(
@@ -140,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
 
@@ -187,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
@@ -224,42 +109,31 @@ 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
 
@@ -271,7 +145,6 @@ class BulkHookManager(models.Manager):
             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(
@@ -281,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]
+            # Run validation hooks first
+            if not bypass_validation:
+                engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
 
-                if not bypass_validation:
-                    engine.run(model_cls, VALIDATE_DELETE, chunk, ctx=ctx)
-                engine.run(model_cls, BEFORE_DELETE, chunk, ctx=ctx)
+            # Then run business logic hooks
+            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
 
-        # Collect PKs and delete in chunks
         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

@@ -14,35 +14,6 @@ from django_bulk_hooks.constants import (
 from django_bulk_hooks.context import HookContext
 from django_bulk_hooks.engine import run
 from django_bulk_hooks.manager import BulkHookManager
-from django.db.models.fields.related_descriptors import ForwardManyToOneDescriptor
-from functools import wraps
-import contextlib
-
-
-@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):
@@ -57,70 +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__)
 
-        # Use a single context manager for all hooks
-        with patch_foreign_key_behavior():
-            if is_create:
-                # For create operations
+        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)
+
                 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__, 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
-                    run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-                    super().save(*args, **kwargs)
-                    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

django_bulk_hooks/queryset.py

@@ -18,8 +18,9 @@ class HookQuerySet(models.QuerySet):
         model_cls = self.model
         pks = [obj.pk for obj in instances]
 
-        # Load originals for hook comparison
-        originals = list(model_cls.objects.filter(pk__in=pks))
+        # Load originals for hook comparison and ensure they match the order of instances
+        original_map = {obj.pk: obj for obj in model_cls.objects.filter(pk__in=pks)}
+        originals = [original_map.get(obj.pk) for obj in instances]
 
         # Apply field updates to instances
         for obj in instances:

django_bulk_hooks/registry.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from typing import Union
 
-from django_bulk_hooks.enums import Priority
+from django_bulk_hooks.priority import Priority
 
 _hooks: dict[tuple[type, str], list[tuple[type, str, Callable, int]]] = {}
 
@@ -17,7 +17,8 @@ def register_hook(
 
 
 def get_hooks(model, event):
-    return _hooks.get((model, event), [])
+    hooks = _hooks.get((model, event), [])
+    return hooks
 
 
 def list_all_hooks():