django-bulk-hooks 0.1.231__py3-none-any.whl → 0.1.233__py3-none-any.whl

django_bulk_hooks/engine.py

@@ -1,59 +1,33 @@
 import logging
 
 from django.core.exceptions import ValidationError
-from django.db import transaction
-from django.conf import settings
 
 from django_bulk_hooks.registry import get_hooks
-from django_bulk_hooks.handler import hook_vars
 
 logger = logging.getLogger(__name__)
 
 
-class AggregatedHookError(Exception):
-    """Raised when multiple hook handlers fail under best-effort policy."""
-
-    def __init__(self, errors):
-        self.errors = errors
-        message_lines = [
-            "Multiple hook errors occurred:",
-            *(f"- {ctx}: {exc}" for ctx, exc in errors),
-        ]
-        super().__init__("\n".join(message_lines))
-
-
 def run(model_cls, event, new_records, old_records=None, ctx=None):
     """
     Run hooks for a given model, event, and records.
-
-    Production-grade executor:
-    - Honors bypass_hooks via ctx
-    - Runs model.clean() before BEFORE_* events for validation
-    - Executes hooks in registry priority order with condition filtering
-    - Exposes thread-local context via hook_vars during execution
-    - AFTER_* timing is configurable via settings.BULK_HOOKS_AFTER_ON_COMMIT (default: False)
-
-    Args:
-        model_cls: The Django model class
-        event: The hook event (e.g., 'before_create', 'after_update')
-        new_records: List of new/updated records
-        old_records: List of original records (for comparison)
-        ctx: Optional hook context
     """
     if not new_records:
         return
 
+    # Get hooks for this model and event
     hooks = get_hooks(model_cls, event)
+
     if not hooks:
         return
 
-    logger.debug(
-        f"Running {len(hooks)} hooks for {model_cls.__name__}.{event} ({len(new_records)} records)"
-    )
+    import traceback
 
+    stack = traceback.format_stack()
+    logger.debug(f"engine.run {model_cls.__name__}.{event} {len(new_records)} records")
+    
     # Check if we're in a bypass context
-    if ctx and hasattr(ctx, "bypass_hooks") and ctx.bypass_hooks:
-        logger.debug("Hook execution bypassed")
+    if ctx and hasattr(ctx, 'bypass_hooks') and ctx.bypass_hooks:
+        logger.debug("engine.run bypassed")
         return
 
     # For BEFORE_* events, run model.clean() first for validation
@@ -65,96 +39,36 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
                 logger.error("Validation failed for %s: %s", instance, e)
                 raise
 
-    def _execute():
-        hook_vars.depth += 1
-        hook_vars.event = event
-
-        try:
-            # Build deterministic pairing of new and old by primary key when possible
-            def pair_records(new_list, old_list):
-                if not old_list:
-                    # No old records; pair each new with None
-                    return [(n, None) for n in new_list]
-
-                # If all new have PKs, align by PK preserving new order
-                if all(getattr(n, "pk", None) is not None for n in new_list):
-                    old_by_pk = {getattr(o, "pk", None): o for o in old_list if o is not None}
-                    pairs = []
-                    for n in new_list:
-                        pk = getattr(n, "pk", None)
-                        pairs.append((n, old_by_pk.get(pk)))
-                    return pairs
-
-                # Fallback: best-effort positional pairing (create flows etc.)
-                pairs = []
-                for idx, n in enumerate(new_list):
-                    o = old_list[idx] if idx < len(old_list) else None
-                    pairs.append((n, o))
-                return pairs
-
-            pairs = pair_records(new_records, old_records or [])
-
-            failure_policy = getattr(settings, "BULK_HOOKS_FAILURE_POLICY", "fail_fast")
-            collected_errors = []
-
-            for handler_cls, method_name, condition, priority in hooks:
-                try:
-                    handler_instance = handler_cls()
-                    func = getattr(handler_instance, method_name)
-                except Exception as e:
-                    logger.error(
-                        "Failed to instantiate %s.%s: %s",
-                        handler_cls.__name__,
-                        method_name,
-                        e,
-                    )
-                    continue
-
-                # Condition filtering per record using the deterministic pairs
-                to_process_new = []
-                to_process_old = []
-                for new_obj, old_obj in pairs:
-                    if not condition:
-                        to_process_new.append(new_obj)
-                        to_process_old.append(old_obj)
-                    else:
-                        try:
-                            if condition.check(new_obj, old_obj):
-                                to_process_new.append(new_obj)
-                                to_process_old.append(old_obj)
-                        except Exception as e:
-                            logger.error(
-                                "Condition failed for %s.%s: %s",
-                                handler_cls.__name__,
-                                method_name,
-                                e,
-                            )
-                            continue
-
-                if not to_process_new:
-                    continue
-
-                try:
-                    func(
-                        new_records=to_process_new,
-                        old_records=to_process_old if any(x is not None for x in to_process_old) else None,
-                    )
-                except Exception as e:
-                    logger.exception(
-                        "Error in hook %s.%s", handler_cls.__name__, method_name
-                    )
-                    if failure_policy == "best_effort":
-                        collected_errors.append((f"{handler_cls.__name__}.{method_name}", e))
-                        continue
-                    # fail_fast
-                    raise
-
-            if collected_errors:
-                raise AggregatedHookError(collected_errors)
-        finally:
-            hook_vars.event = None
-            hook_vars.depth -= 1
-
-    # Execute immediately so AFTER_* runs within the transaction.
-    # If a hook raises, the transaction is rolled back (Salesforce-style).
-    _execute()
+    # Process hooks
+    for handler_cls, method_name, condition, priority in hooks:
+        logger.debug(f"Processing {handler_cls.__name__}.{method_name}")
+        handler_instance = handler_cls()
+        func = getattr(handler_instance, method_name)
+
+        to_process_new = []
+        to_process_old = []
+
+        for new, original in zip(
+            new_records,
+            old_records or [None] * len(new_records),
+            strict=True,
+        ):
+            if not condition:
+                to_process_new.append(new)
+                to_process_old.append(original)
+            else:
+                condition_result = condition.check(new, original)
+                if condition_result:
+                    to_process_new.append(new)
+                    to_process_old.append(original)
+
+        if to_process_new:
+            logger.debug(f"Executing {handler_cls.__name__}.{method_name} for {len(to_process_new)} records")
+            try:
+                func(
+                    new_records=to_process_new,
+                    old_records=to_process_old if any(to_process_old) else None,
+                )
+            except Exception as e:
+                logger.debug(f"Hook execution failed: {e}")
+                raise

django_bulk_hooks/enums.py

@@ -1,14 +1,17 @@
-"""
-Compatibility layer for priority-related exports.
+from enum import IntEnum
 
-This module re-exports the canonical Priority enum and a DEFAULT_PRIORITY
-constant so existing imports like `from django_bulk_hooks.enums import ...`
-continue to work without churn. Prefer importing from `priority` in new code.
-"""
 
-from django_bulk_hooks.priority import Priority
+class Priority(IntEnum):
+    """
+    Named priorities for django-bulk-hooks hooks.
+    Replaces module-level constants with a clean IntEnum.
+    """
+
+    HIGHEST = 0  # runs first
+    HIGH = 25  # runs early
+    NORMAL = 50  # default ordering
+    LOW = 75  # runs late
+    LOWEST = 100  # runs last
 
-# Default priority used when none is specified by the hook decorator
-DEFAULT_PRIORITY = Priority.NORMAL
 
-__all__ = ["Priority", "DEFAULT_PRIORITY"]
+DEFAULT_PRIORITY = Priority.NORMAL

django_bulk_hooks/handler.py

@@ -2,7 +2,9 @@ import logging
 import threading
 from collections import deque
 
-from django_bulk_hooks.registry import register_hook
+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
 
 
@@ -108,11 +97,16 @@ class Hook(metaclass=HookMeta):
         old_records: list = None,
         **kwargs,
     ) -> None:
-        """
-        Legacy entrypoint; delegate to the unified executor in engine.run.
-        """
-        from django_bulk_hooks.engine import run as run_engine
-        run_engine(model, event, new_records or [], old_records or None, ctx=kwargs.get("ctx"))
+        queue = get_hook_queue()
+        queue.append((cls, event, model, new_records, old_records, kwargs))
+
+        if len(queue) > 1:
+            return  # nested call, will be processed by outermost
+
+        # only outermost handle will process the queue
+        while queue:
+            cls_, event_, model_, new_, old_, kw_ = queue.popleft()
+            cls_._process(event_, model_, new_, old_, **kw_)
 
     @classmethod
     def _process(
@@ -123,12 +117,51 @@ class Hook(metaclass=HookMeta):
         old_records,
         **kwargs,
     ):
-        """
-        Legacy internal; delegate to engine.run to avoid divergence.
-        """
-        from django_bulk_hooks.engine import run as run_engine
-        run_engine(model, event, new_records or [], old_records or None, ctx=kwargs.get("ctx"))
-
-
-# Create a global Hook instance for context access
-HookContext = HookContextState()
+        hook_vars.depth += 1
+        hook_vars.new = new_records
+        hook_vars.old = old_records
+        hook_vars.event = event
+        hook_vars.model = model
+
+        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
+
+        def _execute():
+            new_local = new_records or []
+            old_local = old_records or []
+            if len(old_local) < len(new_local):
+                old_local += [None] * (len(new_local) - len(old_local))
+
+            for handler_cls, method_name, condition, priority in hooks:
+                if condition is not None:
+                    checks = [
+                        condition.check(n, o) for n, o in zip(new_local, old_local)
+                    ]
+                    if not any(checks):
+                        continue
+
+                handler = handler_cls()
+                method = getattr(handler, method_name)
+
+                try:
+                    method(
+                        new_records=new_local,
+                        old_records=old_local,
+                        **kwargs,
+                    )
+                except Exception:
+                    logger.exception(
+                        "Error in hook %s.%s", handler_cls.__name__, method_name
+                    )
+
+        conn = transaction.get_connection()
+        try:
+            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

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