django-bulk-hooks 0.1.53__tar.gz → 0.1.54__tar.gz

{django_bulk_hooks-0.1.53 → django_bulk_hooks-0.1.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.53
+Version: 0.1.54
 Summary: Lifecycle-style hooks for Django bulk operations like bulk_create and bulk_update.
 Home-page: https://github.com/AugendLimited/django-bulk-hooks
 License: MIT

django_bulk_hooks-0.1.54/django_bulk_hooks/context.py

@@ -0,0 +1,16 @@
+import threading
+from collections import deque
+
+_hook_context = threading.local()
+
+
+def get_hook_queue():
+    if not hasattr(_hook_context, "queue"):
+        _hook_context.queue = deque()
+    return _hook_context.queue
+
+
+class TriggerContext:
+    def __init__(self, model_cls, metadata=None):
+        self.model_cls = model_cls
+        self.metadata = metadata or {}

django_bulk_hooks-0.1.54/django_bulk_hooks/handler.py

@@ -0,0 +1,102 @@
+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__)
+
+# Thread-local hook queue context
+_hook_context = threading.local()
+
+def get_hook_queue():
+    if not hasattr(_hook_context, "queue"):
+        _hook_context.queue = deque()
+    return _hook_context.queue
+
+class TriggerHandlerMeta(type):
+    _registered = set()
+
+    def __new__(mcs, name, bases, namespace):
+        cls = super().__new__(mcs, name, bases, namespace)
+        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 TriggerHandlerMeta._registered:
+                        register_hook(
+                            model=model_cls,
+                            event=event,
+                            handler_cls=cls,
+                            method_name=method_name,
+                            condition=condition,
+                            priority=priority,
+                        )
+                        TriggerHandlerMeta._registered.add(key)
+        return cls
+
+class TriggerHandler(metaclass=TriggerHandlerMeta):
+    @classmethod
+    def handle(
+        cls,
+        event: str,
+        model: type,
+        *,
+        new_records: list = None,
+        old_records: list = None,
+        **kwargs,
+    ) -> None:
+        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(
+        cls,
+        event,
+        model,
+        new_records,
+        old_records,
+        **kwargs,
+    ):
+        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
+        logger.debug("Processing %d hooks for %s.%s", len(hooks), model.__name__, event)
+
+        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)
+
+                logger.info("Running hook %s.%s on %d items", handler_cls.__name__, method_name, len(new_local))
+                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()
+        if conn.in_atomic_block and event.startswith("after_"):
+            transaction.on_commit(_execute)
+        else:
+            _execute()

{django_bulk_hooks-0.1.53 → django_bulk_hooks-0.1.54}/django_bulk_hooks/queryset.py

@@ -1,5 +1,4 @@
 from django.db import models, transaction
-from django.db.models.manager import BaseManager
 
 
 class LifecycleQuerySet(models.QuerySet):

{django_bulk_hooks-0.1.53 → django_bulk_hooks-0.1.54}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.53"
+version = "0.1.54"
 description = "Lifecycle-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.53/django_bulk_hooks/context.py

@@ -1,4 +0,0 @@
-class TriggerContext:
-    def __init__(self, model_cls, metadata=None):
-        self.model_cls = model_cls
-        self.metadata = metadata or {}

django_bulk_hooks-0.1.53/django_bulk_hooks/handler.py

@@ -1,208 +0,0 @@
-import logging
-
-from django.db import transaction
-from django_bulk_hooks.conditions import HookCondition
-from django_bulk_hooks.registry import get_hooks, register_hook
-
-logger = logging.getLogger(__name__)
-
-
-class TriggerHandlerMeta(type):
-    _registered = set()
-
-    def __new__(mcs, name, bases, namespace):
-        cls = super().__new__(mcs, name, bases, namespace)
-        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 in TriggerHandlerMeta._registered:
-                        logger.debug(
-                            "Skipping duplicate registration for %s.%s on %s.%s",
-                            cls.__name__,
-                            method_name,
-                            model_cls.__name__,
-                            event,
-                        )
-                    else:
-                        register_hook(
-                            model=model_cls,
-                            event=event,
-                            handler_cls=cls,
-                            method_name=method_name,
-                            condition=condition,
-                            priority=priority,
-                        )
-                        TriggerHandlerMeta._registered.add(key)
-                        logger.debug(
-                            "Registered hook %s.%s → %s.%s (cond=%r, prio=%s)",
-                            model_cls.__name__,
-                            event,
-                            cls.__name__,
-                            method_name,
-                            condition,
-                            priority,
-                        )
-        return cls
-
-
-class TriggerHandler(metaclass=TriggerHandlerMeta):
-    @classmethod
-    def handle(
-        cls,
-        event: str,
-        model: type,
-        *,
-        new_records: list = None,
-        old_records: list = None,
-        **kwargs,
-    ) -> None:
-        # Prepare hook list and log names
-        hooks = get_hooks(model, event)
-
-        # Sort hooks by priority (ascending: lower number = higher priority)
-        hooks = sorted(hooks, key=lambda x: x[3])
-
-        hook_names = [f"{h.__name__}.{m}" for h, m, _, _ in hooks]
-        logger.debug(
-            "Found %d hooks for %s.%s: %s",
-            len(hooks),
-            model.__name__,
-            event,
-            hook_names,
-        )
-
-        def _process():
-            # Ensure new_records is a list
-            new_records_local = new_records or []
-
-            # Normalize old_records: ensure list and pad with None
-            old_records_local = list(old_records) if old_records else []
-            if len(old_records_local) < len(new_records_local):
-                old_records_local += [None] * (
-                    len(new_records_local) - len(old_records_local)
-                )
-
-            logger.debug(
-                "ℹ️  bulk_hooks.handle() start: model=%s event=%s new_count=%d old_count=%d",
-                model.__name__,
-                event,
-                len(new_records_local),
-                len(old_records_local),
-            )
-
-            for handler_cls, method_name, condition, priority in hooks:
-                logger.debug(
-                    "→ evaluating hook %s.%s (cond=%r, prio=%s)",
-                    handler_cls.__name__,
-                    method_name,
-                    condition,
-                    priority,
-                )
-
-                # Evaluate condition
-                passed = True
-                if condition is not None:
-                    if isinstance(condition, HookCondition):
-                        cond_info = getattr(condition, "__dict__", str(condition))
-                        logger.debug(
-                            "   [cond-info] %s.%s → %r",
-                            handler_cls.__name__,
-                            method_name,
-                            cond_info,
-                        )
-
-                        checks = []
-                        for new, old in zip(new_records_local, old_records_local):
-                            field_name = getattr(condition, "field", None) or getattr(
-                                condition, "field_name", None
-                            )
-                            if field_name:
-                                actual_val = getattr(new, field_name, None)
-                                expected = getattr(condition, "value", None) or getattr(
-                                    condition, "value", None
-                                )
-                                logger.debug(
-                                    "   [field-lookup] %s.%s → field=%r actual=%r expected=%r",
-                                    handler_cls.__name__,
-                                    method_name,
-                                    field_name,
-                                    actual_val,
-                                    expected,
-                                )
-                            result = condition.check(new, old)
-                            checks.append(result)
-                            logger.debug(
-                                "   [cond-check] %s.%s → new=%r old=%r => %s",
-                                handler_cls.__name__,
-                                method_name,
-                                new,
-                                old,
-                                result,
-                            )
-                        passed = any(checks)
-                        logger.debug(
-                            "   [cond-summary] %s.%s any-passed=%s",
-                            handler_cls.__name__,
-                            method_name,
-                            passed,
-                        )
-                    else:
-                        # Legacy callable conditions
-                        passed = condition(
-                            new_records=new_records_local,
-                            old_records=old_records_local,
-                        )
-                        logger.debug(
-                            "   [legacy-cond] %s.%s → full-list => %s",
-                            handler_cls.__name__,
-                            method_name,
-                            passed,
-                        )
-
-                if not passed:
-                    logger.debug(
-                        "↳ skipping %s.%s (condition not met)",
-                        handler_cls.__name__,
-                        method_name,
-                    )
-                    continue
-
-                # Instantiate & invoke handler method
-                handler = handler_cls()
-                method = getattr(handler, method_name)
-                logger.info(
-                    "✨ invoking %s.%s on %d record(s)",
-                    handler_cls.__name__,
-                    method_name,
-                    len(new_records_local),
-                )
-                try:
-                    method(
-                        new_records=new_records_local,
-                        old_records=old_records_local,
-                        **kwargs,
-                    )
-                except Exception:
-                    logger.exception(
-                        "❌ exception in %s.%s",
-                        handler_cls.__name__,
-                        method_name,
-                    )
-
-            logger.debug(
-                "✔️  bulk_hooks.handle() complete for %s.%s",
-                model.__name__,
-                event,
-            )
-
-        # Defer if in atomic block and event is after_*
-        conn = transaction.get_connection()
-        if conn.in_atomic_block and event.startswith("after_"):
-            logger.debug(
-                "Deferring hook execution until after transaction commit for event '%s'",
-                event,
-            )
-            transaction.on_commit(_process)
-        else:
-            _process()