django-bulk-hooks 0.1.227__py3-none-any.whl → 0.1.229__py3-none-any.whl

django_bulk_hooks/handler.py

@@ -2,8 +2,6 @@ import logging
 import threading
 from collections import deque
 
-from django.db import transaction
-
 from django_bulk_hooks.registry import get_hooks, register_hook
 
 logger = logging.getLogger(__name__)
@@ -61,36 +59,40 @@ class HookContextState:
         return hook_vars.model
 
 
-Hook = HookContextState()
-
-
 class HookMeta(type):
     """Metaclass that automatically registers hooks when Hook classes are defined."""
     
     def __new__(mcs, name, bases, namespace):
         cls = super().__new__(mcs, name, bases, namespace)
         
-        # Register hooks for this class
-        for method_name, method in namespace.items():
-            if hasattr(method, "hooks_hooks"):
-                for model_cls, event, condition, priority in method.hooks_hooks:
-                    # Create a unique key for this hook registration
-                    key = (model_cls, event, cls, method_name)
-                    
-                    # Register the hook
-                    register_hook(
-                        model=model_cls,
-                        event=event,
-                        handler_cls=cls,
-                        method_name=method_name,
-                        condition=condition,
-                        priority=priority,
-                    )
-                    
-                    logger.debug(
-                        f"Registered hook {cls.__name__}.{method_name} "
-                        f"for {model_cls.__name__}.{event} with priority {priority}"
-                    )
+        # 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:
+                        # Register the hook
+                        register_hook(
+                            model=model_cls,
+                            event=event,
+                            handler_cls=cls,
+                            method_name=attr_name,
+                            condition=condition,
+                            priority=priority,
+                        )
+                        
+                        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
 
@@ -132,7 +134,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 []
@@ -161,16 +163,18 @@ 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:
-            if conn.in_atomic_block and event.startswith("after_"):
-                transaction.on_commit(_execute)
-            else:
-                _execute()
+            _execute()
         finally:
             hook_vars.new = None
             hook_vars.old = None
             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/manager.py

@@ -1,113 +1,135 @@
+from typing import Iterable, Sequence, Any
 from django.db import models
 
 from django_bulk_hooks.queryset import HookQuerySet, HookQuerySetMixin
 
 
 class BulkHookManager(models.Manager):
-    def get_queryset(self):
-        # Use super().get_queryset() to let Django and MRO build the queryset
-        # This ensures cooperation with other managers
-        base_queryset = super().get_queryset()
-        
-        # If the base queryset already has hook functionality, return it as-is
-        if isinstance(base_queryset, HookQuerySetMixin):
-            return base_queryset
-        
-        # Otherwise, create a new HookQuerySet with the same parameters
-        # This is much simpler and avoids dynamic class creation issues
-        return HookQuerySet(
-            model=base_queryset.model,
-            query=base_queryset.query,
-            using=base_queryset._db,
-            hints=base_queryset._hints
-        )
+	"""Manager that ensures all queryset operations are hook-aware.
 
-    def bulk_create(
-        self,
-        objs,
-        batch_size=None,
-        ignore_conflicts=False,
-        update_conflicts=False,
-        update_fields=None,
-        unique_fields=None,
-        bypass_hooks=False,
-        bypass_validation=False,
-        **kwargs,
-    ):
-        """
-        Delegate to QuerySet's bulk_create implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().bulk_create(
-            objs,
-            bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
-            batch_size=batch_size,
-            ignore_conflicts=ignore_conflicts,
-            update_conflicts=update_conflicts,
-            update_fields=update_fields,
-            unique_fields=unique_fields,
-            **kwargs,
-        )
+	Delegates operations to a hook-enabled queryset while preserving any
+	customizations from other managers in the MRO by starting with
+	``super().get_queryset()``.
+	"""
 
-    def bulk_update(
-        self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
-    ):
-        """
-        Delegate to QuerySet's bulk_update implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().bulk_update(
-            objs,
-            fields,
-            bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
-            **kwargs,
-        )
+	# Cache for composed queryset classes to preserve custom queryset APIs
+	_qs_compose_cache = {}
 
-    def bulk_delete(
-        self,
-        objs,
-        batch_size=None,
-        bypass_hooks=False,
-        bypass_validation=False,
-        **kwargs,
-    ):
-        """
-        Delegate to QuerySet's bulk_delete implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().bulk_delete(
-            objs,
-            bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
-            batch_size=batch_size,
-            **kwargs,
-        )
+	def get_queryset(self) -> HookQuerySet:
+		# Use super().get_queryset() to let Django and MRO build the queryset
+		base_queryset = super().get_queryset()
 
-    def delete(self):
-        """
-        Delegate to QuerySet's delete implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().delete()
+		# If the base queryset already has hook functionality, return it as-is
+		if isinstance(base_queryset, HookQuerySetMixin):
+			return base_queryset  # type: ignore[return-value]
 
-    def update(self, **kwargs):
-        """
-        Delegate to QuerySet's update implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().update(**kwargs)
+		# Otherwise, dynamically compose a queryset class that preserves the
+		# base queryset's custom API while adding hook behavior
+		base_cls = base_queryset.__class__
+		composed_cls = self._qs_compose_cache.get(base_cls)
+		if composed_cls is None:
+			composed_name = f"ComposedHookQuerySet_{base_cls.__name__}"
+			composed_cls = type(composed_name, (HookQuerySetMixin, base_cls), {})
+			self._qs_compose_cache[base_cls] = composed_cls
 
-    def save(self, obj):
-        """
-        Save a single object using the appropriate bulk operation.
-        """
-        if obj.pk:
-            self.bulk_update(
-                [obj],
-                fields=[field.name for field in obj._meta.fields if field.name != "id"],
-            )
-        else:
-            self.bulk_create([obj])
-        return obj
+		return composed_cls(
+			model=base_queryset.model,
+			query=base_queryset.query,
+			using=base_queryset._db,
+			hints=base_queryset._hints,
+		)
+
+	def bulk_create(
+		self,
+		objs: Iterable[models.Model],
+		batch_size: int | None = None,
+		ignore_conflicts: bool = False,
+		update_conflicts: bool = False,
+		update_fields: Sequence[str] | None = None,
+		unique_fields: Sequence[str] | None = None,
+		bypass_hooks: bool = False,
+		bypass_validation: bool = False,
+		**kwargs: Any,
+	) -> list[models.Model]:
+		"""
+		Delegate to QuerySet's bulk_create implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().bulk_create(
+			objs,
+			bypass_hooks=bypass_hooks,
+			bypass_validation=bypass_validation,
+			batch_size=batch_size,
+			ignore_conflicts=ignore_conflicts,
+			update_conflicts=update_conflicts,
+			update_fields=update_fields,
+			unique_fields=unique_fields,
+			**kwargs,
+		)
+
+	def bulk_update(
+		self,
+		objs: Iterable[models.Model],
+		fields: Sequence[str],
+		bypass_hooks: bool = False,
+		bypass_validation: bool = False,
+		**kwargs: Any,
+	) -> int:
+		"""
+		Delegate to QuerySet's bulk_update implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().bulk_update(
+			objs,
+			fields,
+			bypass_hooks=bypass_hooks,
+			bypass_validation=bypass_validation,
+			**kwargs,
+		)
+
+	def bulk_delete(
+		self,
+		objs: Iterable[models.Model],
+		batch_size: int | None = None,
+		bypass_hooks: bool = False,
+		bypass_validation: bool = False,
+		**kwargs: Any,
+	) -> int:
+		"""
+		Delegate to QuerySet's bulk_delete implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().bulk_delete(
+			objs,
+			bypass_hooks=bypass_hooks,
+			bypass_validation=bypass_validation,
+			batch_size=batch_size,
+			**kwargs,
+		)
+
+	def delete(self) -> int:
+		"""
+		Delegate to QuerySet's delete implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().delete()
+
+	def update(self, **kwargs: Any) -> int:
+		"""
+		Delegate to QuerySet's update implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().update(**kwargs)
+
+	def save(self, obj: models.Model) -> models.Model:
+		"""
+		Save a single object using the appropriate bulk operation.
+		"""
+		if obj.pk:
+			self.bulk_update(
+				[obj],
+				fields=[field.name for field in obj._meta.fields if field.name != "id"],
+			)
+		else:
+			self.bulk_create([obj])
+		return obj

django_bulk_hooks/models.py

@@ -1,6 +1,5 @@
 import logging
-from django.db import models
-
+from django.db import models, transaction
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -42,18 +41,18 @@ class HookModelMixin(models.Model):
 
         if is_create:
             # For create operations, run VALIDATE_CREATE hooks for validation
-            ctx = HookContext(self.__class__)
+            ctx = HookContext(self.__class__, bypass_hooks)
             run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
         else:
             # For update operations, run VALIDATE_UPDATE hooks for validation
             try:
                 # Use _base_manager to avoid triggering hooks recursively
                 old_instance = self.__class__._base_manager.get(pk=self.pk)
-                ctx = HookContext(self.__class__)
+                ctx = HookContext(self.__class__, bypass_hooks)
                 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__)
+                ctx = HookContext(self.__class__, bypass_hooks)
                 run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
 
     def save(self, *args, bypass_hooks=False, **kwargs):
@@ -62,12 +61,27 @@ class HookModelMixin(models.Model):
             logger.debug(f"save() called with bypass_hooks=True for {self.__class__.__name__} pk={self.pk}")
             return self._base_manager.save(self, *args, **kwargs)
 
-        is_create = self.pk is None
+        # Only create a new transaction if we're not already in one
+        # This allows for proper nested transaction handling
+        from django.db import connection
+        if connection.in_atomic_block:
+            # We're already in a transaction, don't create a new one
+            return self._save_with_hooks(*args, **kwargs)
+        else:
+            # We're not in a transaction, so create one
+            with transaction.atomic():
+                return self._save_with_hooks(*args, **kwargs)
 
+    def _save_with_hooks(self, *args, **kwargs):
+        """Internal method to handle save with hooks."""
+        is_create = self.pk is None
+        
         if is_create:
             logger.debug(f"save() creating new {self.__class__.__name__} instance")
             # For create operations, we don't have old records
-            ctx = HookContext(self.__class__)
+            ctx = HookContext(self.__class__, bypass_hooks=False)
+            
+            # Run hooks - if any fail, the transaction will be rolled back
             run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
             run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
 
@@ -80,7 +94,9 @@ class HookModelMixin(models.Model):
             try:
                 # Use _base_manager to avoid triggering hooks recursively
                 old_instance = self.__class__._base_manager.get(pk=self.pk)
-                ctx = HookContext(self.__class__)
+                ctx = HookContext(self.__class__, bypass_hooks=False)
+                
+                # Run hooks - if any fail, the transaction will be rolled back
                 run(self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx)
                 run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
 
@@ -89,7 +105,9 @@ class HookModelMixin(models.Model):
                 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__)
+                ctx = HookContext(self.__class__, bypass_hooks=False)
+                
+                # Run hooks - if any fail, the transaction will be rolled back
                 run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
                 run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
 
@@ -104,9 +122,22 @@ class HookModelMixin(models.Model):
         if bypass_hooks:
             return self._base_manager.delete(self, *args, **kwargs)
 
-        ctx = HookContext(self.__class__)
+        # Only create a new transaction if we're not already in one
+        # This allows for proper nested transaction handling
+        from django.db import connection
+        if connection.in_atomic_block:
+            # We're already in a transaction, don't create a new one
+            return self._delete_with_hooks(*args, **kwargs)
+        else:
+            # We're not in a transaction, so create one
+            with transaction.atomic():
+                return self._delete_with_hooks(*args, **kwargs)
+
+    def _delete_with_hooks(self, *args, **kwargs):
+        """Internal method to handle delete with hooks."""
+        ctx = HookContext(self.__class__, bypass_hooks=False)
 
-        # Run validation hooks first
+        # Run hooks - if any fail, the transaction will be rolled back
         run(self.__class__, VALIDATE_DELETE, [self], ctx=ctx)
 
         # Then run business logic hooks

django_bulk_hooks/priority.py

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