django-bulk-hooks 0.1.84__tar.gz → 0.1.86__tar.gz

{django_bulk_hooks-0.1.84 → django_bulk_hooks-0.1.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.84
+Version: 0.1.86
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.1.84 → django_bulk_hooks-0.1.86}/django_bulk_hooks/engine.py

@@ -8,7 +8,12 @@ from django_bulk_hooks.conditions import safe_get_related_object, safe_get_relat
 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:
@@ -32,19 +37,32 @@ def run(model_cls, event, new_instances, original_instances=None, ctx=None):
                     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 in hooks:
-        handler_instance = handler_cls()
-        func = getattr(handler_instance, method_name)
+        # 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]
+
+        # If no condition, process all instances at once
+        if not condition:
+            func(new_records=new_instances, old_records=original_instances if any(original_instances) else None)
+            continue
 
+        # For conditional hooks, filter instances first
         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):
+        for new, original in zip(new_instances, original_instances, strict=True):
+            if condition.check(new, original):
                 to_process_new.append(new)
                 to_process_old.append(original)
 

django_bulk_hooks-0.1.86/django_bulk_hooks/models.py

@@ -0,0 +1,126 @@
+from django.db import models, transaction
+
+from django_bulk_hooks.constants import (
+    AFTER_CREATE,
+    AFTER_DELETE,
+    AFTER_UPDATE,
+    BEFORE_CREATE,
+    BEFORE_DELETE,
+    BEFORE_UPDATE,
+    VALIDATE_CREATE,
+    VALIDATE_DELETE,
+    VALIDATE_UPDATE,
+)
+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):
+    objects = BulkHookManager()
+
+    class Meta:
+        abstract = True
+
+    def clean(self):
+        """
+        Override clean() to trigger validation hooks.
+        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)
+        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)
+            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)
+
+    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
+                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)
+            
+        return result

{django_bulk_hooks-0.1.84 → django_bulk_hooks-0.1.86}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.84"
+version = "0.1.86"
 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.84/django_bulk_hooks/models.py

@@ -1,106 +0,0 @@
-from django.db import models, transaction
-
-from django_bulk_hooks.constants import (
-    AFTER_CREATE,
-    AFTER_DELETE,
-    AFTER_UPDATE,
-    BEFORE_CREATE,
-    BEFORE_DELETE,
-    BEFORE_UPDATE,
-    VALIDATE_CREATE,
-    VALIDATE_DELETE,
-    VALIDATE_UPDATE,
-)
-from django_bulk_hooks.context import HookContext
-from django_bulk_hooks.engine import run
-from django_bulk_hooks.manager import BulkHookManager
-
-
-class HookModelMixin(models.Model):
-    objects = BulkHookManager()
-
-    class Meta:
-        abstract = True
-
-    def clean(self):
-        """
-        Override clean() to trigger validation hooks.
-        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__)
-            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__)
-                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__)
-                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
-
-    def save(self, *args, **kwargs):
-        is_create = self.pk is None
-        ctx = HookContext(self.__class__)
-
-        if is_create:
-            # For create operations, run BEFORE hooks first
-            run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-            
-            # Then let Django save
-            super().save(*args, **kwargs)
-            
-            # Then run AFTER hooks
-            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)
-                
-                # Run BEFORE hooks first
-                run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
-                
-                # Then let Django save
-                super().save(*args, **kwargs)
-                
-                # Then run AFTER hooks
-                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__)
-
-        # 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