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

django_bulk_hooks/manager.py

@@ -17,113 +17,118 @@ 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.
+    CHUNK_SIZE = 200
+
+    def get_queryset(self):
+        return HookQuerySet(self.model, using=self._db)
 
-        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
+    def _has_multi_table_inheritance(self, model_cls):
         """
-        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):
+        Check if this model uses multi-table inheritance.
         """
-        Optimized loading of original instances with smart batching and field selection.
+        return (
+            model_cls._meta.parents and 
+            not all(parent._meta.abstract for parent in model_cls._meta.parents.values())
+        )
+    
+    def _get_base_model(self, model_cls):
         """
-        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)
-
-        return all_originals
-
-    def _get_fields_to_fetch(self, objs, fields):
+        Get the base model (first non-abstract parent or self).
         """
-        Determine which fields need to be fetched based on what's being updated
-        and what's needed for hooks.
+        base_model = model_cls
+        while base_model._meta.parents:
+            parent = next(iter(base_model._meta.parents.values()))
+            if not parent._meta.abstract:
+                base_model = parent
+            else:
+                break
+        return base_model
+    
+    def _extract_base_objects(self, objs, model_cls):
         """
-        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}"
-                )
+        Extract base model objects from inherited objects.
+        """
+        base_model = self._get_base_model(model_cls)
+        base_objects = []
+        
+        for obj in objs:
+            base_obj = base_model()
+            for field in base_model._meta.fields:
+                if field.name != 'id' and hasattr(obj, field.name):
+                    setattr(base_obj, field.name, getattr(obj, field.name))
+            base_objects.append(base_obj)
+        
+        return base_objects
+    
+    def _extract_child_objects(self, objs, model_cls):
+        """
+        Extract child model objects from inherited objects.
+        """
+        child_objects = []
+        
+        for obj in objs:
+            child_obj = model_cls()
+            child_obj.pk = obj.pk  # Set the same PK as base
+            
+            # Copy only fields specific to this model
+            for field in model_cls._meta.fields:
+                if (field.name != 'id' and 
+                    field.model == model_cls and 
+                    hasattr(obj, field.name)):
+                    setattr(child_obj, field.name, getattr(obj, field.name))
+            
+            child_objects.append(child_obj)
+        
+        return child_objects
+    
+    def _bulk_create_inherited(self, objs, **kwargs):
+        """
+        Handle bulk create for inherited models by handling each table separately.
+        """
+        if not objs:
+            return []
+        
+        model_cls = self.model
+        result = []
+        
+        # Group objects by their actual class
+        objects_by_class = {}
+        for obj in objs:
+            obj_class = obj.__class__
+            if obj_class not in objects_by_class:
+                objects_by_class[obj_class] = []
+            objects_by_class[obj_class].append(obj)
+        
+        for obj_class, class_objects in objects_by_class.items():
+            # Check if this class has multi-table inheritance
+            parent_models = [p for p in obj_class._meta.get_parent_list() 
+                           if not p._meta.abstract]
+            
+            if not parent_models:
+                # No inheritance, use standard bulk_create
+                chunk_result = super(models.Manager, self).bulk_create(class_objects, **kwargs)
+                result.extend(chunk_result)
                 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
+            
+            # Handle multi-table inheritance
+            # Step 1: Bulk create base objects without hooks
+            base_objects = self._extract_base_objects(class_objects, obj_class)
+            created_base = super(models.Manager, self).bulk_create(base_objects, **kwargs)
+            
+            # Step 2: Update original objects with base IDs
+            for obj, base_obj in zip(class_objects, created_base):
+                obj.pk = base_obj.pk
+                obj._state.adding = False
+            
+            # Step 3: Bulk create child objects without hooks
+            child_objects = self._extract_child_objects(class_objects, obj_class)
+            if child_objects:
+                # Use _base_manager to avoid recursion
+                obj_class._base_manager.bulk_create(child_objects, **kwargs)
+            
+            result.extend(class_objects)
+        
+        return result
 
     @transaction.atomic
     def bulk_update(
@@ -140,42 +145,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 +186,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 +217,43 @@ 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)}"
             )
 
+        # Check if this model uses multi-table inheritance
+        has_multi_table_inheritance = self._has_multi_table_inheritance(model_cls)
+
+        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)
+        for i in range(0, len(objs), self.CHUNK_SIZE):
+            chunk = objs[i : i + self.CHUNK_SIZE]
+            
+            if has_multi_table_inheritance:
+                # Use our multi-table bulk create
+                created_chunk = self._bulk_create_inherited(chunk, **kwargs)
+            else:
+                # Use Django's standard bulk create
+                created_chunk = super(models.Manager, self).bulk_create(chunk, **kwargs)
+            
             result.extend(created_chunk)
 
         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 +265,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 +274,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():