django-bulk-hooks 0.1.230__py3-none-any.whl → 0.1.232__py3-none-any.whl

django_bulk_hooks/handler.py

@@ -2,6 +2,8 @@ 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__)
@@ -59,41 +61,28 @@ class HookContextState:
         return hook_vars.model
 
 
+Hook = HookContextState()
+
+
 class HookMeta(type):
-    """Metaclass that automatically registers hooks when Hook classes are defined."""
-    
+    _registered = set()
+
     def __new__(mcs, name, bases, namespace):
         cls = super().__new__(mcs, name, bases, namespace)
-        
-        # 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
+        for method_name, method in namespace.items():
+            if hasattr(method, "hooks_hooks"):
+                for model_cls, event, condition, priority in method.hooks_hooks:
+                    key = (model_cls, event, cls, method_name)
+                    if key not in HookMeta._registered:
                         register_hook(
                             model=model_cls,
                             event=event,
                             handler_cls=cls,
-                            method_name=attr_name,
+                            method_name=method_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
-        
+                        HookMeta._registered.add(key)
         return cls
 
 
@@ -134,7 +123,7 @@ class Hook(metaclass=HookMeta):
         hook_vars.event = event
         hook_vars.model = model
 
-        hooks = get_hooks(model, event)
+        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
 
         def _execute():
             new_local = new_records or []
@@ -163,18 +152,16 @@ 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:
-            _execute()
+            if conn.in_atomic_block and event.startswith("after_"):
+                transaction.on_commit(_execute)
+            else:
+                _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,135 +1,113 @@
-from typing import Iterable, Sequence, Any
 from django.db import models
 
 from django_bulk_hooks.queryset import HookQuerySet, HookQuerySetMixin
 
 
 class BulkHookManager(models.Manager):
-	"""Manager that ensures all queryset operations are hook-aware.
+    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
+        )
 
-	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_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,
+        )
 
-	# Cache for composed queryset classes to preserve custom queryset APIs
-	_qs_compose_cache = {}
+    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,
+        )
 
-	def get_queryset(self) -> HookQuerySet:
-		# Use super().get_queryset() to let Django and MRO build the queryset
-		base_queryset = super().get_queryset()
+    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,
+        )
 
-		# 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 delete(self):
+        """
+        Delegate to QuerySet's delete implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return self.get_queryset().delete()
 
-		# 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 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)
 
-		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
+    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

django_bulk_hooks/models.py

@@ -1,5 +1,6 @@
 import logging
-from django.db import models, transaction
+from django.db import models
+
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -41,18 +42,18 @@ class HookModelMixin(models.Model):
 
         if is_create:
             # For create operations, run VALIDATE_CREATE hooks for validation
-            ctx = HookContext(self.__class__, bypass_hooks)
+            ctx = HookContext(self.__class__)
             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__, bypass_hooks)
+                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__, bypass_hooks)
+                ctx = HookContext(self.__class__)
                 run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
 
     def save(self, *args, bypass_hooks=False, **kwargs):
@@ -61,28 +62,12 @@ 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)
 
-        # 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__, bypass_hooks=False)
-            
-            # Run hooks - if any fail, the transaction will be rolled back
-            run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
+            ctx = HookContext(self.__class__)
             run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
 
             super().save(*args, **kwargs)
@@ -94,10 +79,7 @@ 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__, bypass_hooks=False)
-                
-                # Run hooks - if any fail, the transaction will be rolled back
-                run(self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx)
+                ctx = HookContext(self.__class__)
                 run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
 
                 super().save(*args, **kwargs)
@@ -105,10 +87,7 @@ 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__, bypass_hooks=False)
-                
-                # Run hooks - if any fail, the transaction will be rolled back
-                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
+                ctx = HookContext(self.__class__)
                 run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
 
                 super().save(*args, **kwargs)
@@ -122,22 +101,9 @@ class HookModelMixin(models.Model):
         if bypass_hooks:
             return self._base_manager.delete(self, *args, **kwargs)
 
-        # 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)
+        ctx = HookContext(self.__class__)
 
-        # Run hooks - if any fail, the transaction will be rolled back
+        # Run validation hooks first
         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.
 
-    Higher values run earlier (higher priority).
-    Hooks are sorted in descending order.
+    Lower values run earlier (higher priority).
+    Hooks are sorted in ascending order.
     """
 
-    LOWEST = 0  # runs last
-    LOW = 25  # runs later
+    HIGHEST = 0  # runs first
+    HIGH = 25  # runs early
     NORMAL = 50  # default ordering
-    HIGH = 75  # runs early
-    HIGHEST = 100  # runs first
+    LOW = 75  # runs later
+    LOWEST = 100  # runs last