django-bulk-hooks 0.1.238__tar.gz → 0.1.239__tar.gz

{django_bulk_hooks-0.1.238 → django_bulk_hooks-0.1.239}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.238
+Version: 0.1.239
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
-Home-page: https://github.com/AugendLimited/django-bulk-hooks
 License: MIT
 Keywords: django,bulk,hooks
 Author: Konrad Beck
@@ -14,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Django (>=4.0)
+Project-URL: Homepage, https://github.com/AugendLimited/django-bulk-hooks
 Project-URL: Repository, https://github.com/AugendLimited/django-bulk-hooks
 Description-Content-Type: text/markdown
 

django_bulk_hooks-0.1.239/django_bulk_hooks/__init__.py

@@ -0,0 +1,4 @@
+from django_bulk_hooks.handler import Hook as HookClass
+from django_bulk_hooks.manager import BulkHookManager
+
+__all__ = ["BulkHookManager", "HookClass"]

{django_bulk_hooks-0.1.238 → django_bulk_hooks-0.1.239}/django_bulk_hooks/decorators.py

@@ -2,6 +2,7 @@ import inspect
 from functools import wraps
 
 from django.core.exceptions import FieldDoesNotExist
+
 from django_bulk_hooks.enums import DEFAULT_PRIORITY
 from django_bulk_hooks.registry import register_hook
 
@@ -61,13 +62,35 @@ def select_related(*related_fields):
                     continue
                 # if any related field is not already cached on the instance,
                 # mark it for fetching
-                if any(field not in obj._state.fields_cache for field in related_fields):
+                if any(
+                    field not in obj._state.fields_cache for field in related_fields
+                ):
                     ids_to_fetch.append(obj.pk)
 
             fetched = {}
             if ids_to_fetch:
-                # Use the base manager to avoid recursion
-                fetched = model_cls._base_manager.select_related(*related_fields).in_bulk(ids_to_fetch)
+                # Validate fields before passing to select_related
+                validated_fields = []
+                for field in related_fields:
+                    if "." in field:
+                        raise ValueError(
+                            f"@select_related does not support nested fields like '{field}'"
+                        )
+                    try:
+                        f = model_cls._meta.get_field(field)
+                        if not (
+                            f.is_relation and not f.many_to_many and not f.one_to_many
+                        ):
+                            continue
+                        validated_fields.append(field)
+                    except FieldDoesNotExist:
+                        continue
+
+                if validated_fields:
+                    # Use the base manager to avoid recursion
+                    fetched = model_cls._base_manager.select_related(
+                        *validated_fields
+                    ).in_bulk(ids_to_fetch)
 
             for obj in new_records:
                 preloaded = fetched.get(obj.pk)
@@ -78,9 +101,8 @@ def select_related(*related_fields):
                         # don't override values that were explicitly set or already loaded
                         continue
                     if "." in field:
-                        raise ValueError(
-                            f"@preload_related does not support nested fields like '{field}'"
-                        )
+                        # This should have been caught earlier, but just in case
+                        continue
 
                     try:
                         f = model_cls._meta.get_field(field)
@@ -108,30 +130,32 @@ def select_related(*related_fields):
 def bulk_hook(model_cls, event, when=None, priority=None):
     """
     Decorator to register a bulk hook for a model.
-    
+
     Args:
         model_cls: The model class to hook into
         event: The event to hook into (e.g., BEFORE_UPDATE, AFTER_UPDATE)
         when: Optional condition for when the hook should run
         priority: Optional priority for hook execution order
     """
+
     def decorator(func):
         # Create a simple handler class for the function
         class FunctionHandler:
             def __init__(self):
                 self.func = func
-            
+
             def handle(self, new_instances, original_instances):
                 return self.func(new_instances, original_instances)
-        
+
         # Register the hook using the registry
         register_hook(
             model=model_cls,
             event=event,
             handler_cls=FunctionHandler,
-            method_name='handle',
+            method_name="handle",
             condition=when,
             priority=priority or DEFAULT_PRIORITY,
         )
         return func
+
     return decorator

{django_bulk_hooks-0.1.238 → django_bulk_hooks-0.1.239}/django_bulk_hooks/handler.py

@@ -1,167 +1,188 @@
-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 context and hook state
-class HookVars(threading.local):
-    def __init__(self):
-        self.new = None
-        self.old = None
-        self.event = None
-        self.model = None
-        self.depth = 0
-
-
-hook_vars = HookVars()
-
-# Hook queue per thread
-_hook_context = threading.local()
-
-
-def get_hook_queue():
-    if not hasattr(_hook_context, "queue"):
-        _hook_context.queue = deque()
-    return _hook_context.queue
-
-
-class HookContextState:
-    @property
-    def is_before(self):
-        return hook_vars.event.startswith("before_") if hook_vars.event else False
-
-    @property
-    def is_after(self):
-        return hook_vars.event.startswith("after_") if hook_vars.event else False
-
-    @property
-    def is_create(self):
-        return "create" in hook_vars.event if hook_vars.event else False
-
-    @property
-    def is_update(self):
-        return "update" in hook_vars.event if hook_vars.event else False
-
-    @property
-    def new(self):
-        return hook_vars.new
-
-    @property
-    def old(self):
-        return hook_vars.old
-
-    @property
-    def model(self):
-        return hook_vars.model
-
-
-Hook = HookContextState()
-
-
-class HookMeta(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 HookMeta._registered:
-                        register_hook(
-                            model=model_cls,
-                            event=event,
-                            handler_cls=cls,
-                            method_name=method_name,
-                            condition=condition,
-                            priority=priority,
-                        )
-                        HookMeta._registered.add(key)
-        return cls
-
-
-class Hook(metaclass=HookMeta):
-    @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,
-    ):
-        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
+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 context and hook state
+class HookVars(threading.local):
+    def __init__(self):
+        self.new = None
+        self.old = None
+        self.event = None
+        self.model = None
+        self.depth = 0
+
+
+hook_vars = HookVars()
+
+# Hook queue per thread
+_hook_context = threading.local()
+
+
+def get_hook_queue():
+    if not hasattr(_hook_context, "queue"):
+        _hook_context.queue = deque()
+    return _hook_context.queue
+
+
+class HookContextState:
+    @property
+    def is_before(self):
+        return hook_vars.event.startswith("before_") if hook_vars.event else False
+
+    @property
+    def is_after(self):
+        return hook_vars.event.startswith("after_") if hook_vars.event else False
+
+    @property
+    def is_create(self):
+        return "create" in hook_vars.event if hook_vars.event else False
+
+    @property
+    def is_update(self):
+        return "update" in hook_vars.event if hook_vars.event else False
+
+    @property
+    def new(self):
+        return hook_vars.new
+
+    @property
+    def old(self):
+        return hook_vars.old
+
+    @property
+    def model(self):
+        return hook_vars.model
+
+
+HookContext = HookContextState()
+
+
+class HookMeta(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 HookMeta._registered:
+                        register_hook(
+                            model=model_cls,
+                            event=event,
+                            handler_cls=cls,
+                            method_name=method_name,
+                            condition=condition,
+                            priority=priority,
+                        )
+                        HookMeta._registered.add(key)
+        return cls
+
+
+class Hook(metaclass=HookMeta):
+    @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))
+        logger.debug(f"Added item to queue: {event}, depth: {hook_vars.depth}")
+
+        # If we're already processing hooks (depth > 0), don't process the queue
+        # The outermost call will process the entire queue
+        if hook_vars.depth > 0:
+            logger.debug(f"Depth > 0, returning without processing queue")
+            return
+
+        # Process the entire queue
+        logger.debug(f"Processing queue with {len(queue)} items")
+        while queue:
+            item = queue.popleft()
+            if len(item) == 6:
+                cls_, event_, model_, new_, old_, kw_ = item
+                logger.debug(f"Processing queue item: {event_}")
+                # Call _process on the Hook class, not the calling class
+                Hook._process(event_, model_, new_, old_, **kw_)
+            else:
+                logger.warning(f"Invalid queue item format: {item}")
+                continue
+
+    @classmethod
+    def _process(
+        cls,
+        event,
+        model,
+        new_records,
+        old_records,
+        **kwargs,
+    ):
+        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])
+        logger.debug(f"Found {len(hooks)} hooks for {event}")
+
+        def _execute():
+            logger.debug(f"Executing {len(hooks)} hooks for {event}")
+            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:
+                logger.debug(f"Processing hook {handler_cls.__name__}.{method_name}")
+                if condition is not None:
+                    checks = [
+                        condition.check(n, o) for n, o in zip(new_local, old_local)
+                    ]
+                    if not any(checks):
+                        logger.debug(f"Condition failed for {handler_cls.__name__}.{method_name}")
+                        continue
+
+                handler = handler_cls()
+                method = getattr(handler, method_name)
+                logger.debug(f"Executing {handler_cls.__name__}.{method_name}")
+
+                try:
+                    method(
+                        new_records=new_local,
+                        old_records=old_local,
+                        **kwargs,
+                    )
+                    logger.debug(f"Successfully executed {handler_cls.__name__}.{method_name}")
+                except Exception:
+                    logger.exception(
+                        "Error in hook %s.%s", handler_cls.__name__, method_name
+                    )
+
+        conn = transaction.get_connection()
+        logger.debug(f"Transaction in_atomic_block: {conn.in_atomic_block}, event: {event}")
+        try:
+            if conn.in_atomic_block and event.startswith("after_"):
+                logger.debug(f"Deferring {event} to on_commit")
+                transaction.on_commit(_execute)
+            else:
+                logger.debug(f"Executing {event} immediately")
+                _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-0.1.238 → django_bulk_hooks-0.1.239}/django_bulk_hooks/queryset.py

@@ -70,10 +70,20 @@ class HookQuerySetMixin:
         originals = [original_map.get(obj.pk) for obj in instances]
 
         # Check if any of the update values are Subquery objects
+        from django.db.models import Subquery
         has_subquery = any(
-            hasattr(value, "query") and hasattr(value, "resolve_expression")
+            isinstance(value, Subquery)
             for value in kwargs.values()
         )
+        
+        # Debug logging for Subquery detection
+        if has_subquery:
+            logger.debug(f"Detected Subquery in update: {[k for k, v in kwargs.items() if isinstance(v, Subquery)]}")
+        else:
+            # Check if we missed any Subquery objects
+            for k, v in kwargs.items():
+                if hasattr(v, 'query') and hasattr(v, 'resolve_expression'):
+                    logger.warning(f"Potential Subquery-like object detected but not recognized: {k}={type(v).__name__}")
 
         # Apply field updates to instances
         # If a per-object value map exists (from bulk_update), prefer it over kwargs
@@ -175,8 +185,15 @@ class HookQuerySetMixin:
                                 getattr(refreshed_instance, field.name),
                             )
 
-        # Run AFTER_UPDATE hooks only for standalone updates
-        if not current_bypass_hooks:
+        # Run AFTER_UPDATE hooks for standalone updates or subquery operations
+        # For subquery operations, we need to run hooks even if we're in a bulk context
+        # because subqueries bypass the normal object-level update flow
+        should_run_hooks = (
+            not current_bypass_hooks or 
+            has_subquery  # Always run hooks for subquery operations
+        )
+        
+        if should_run_hooks:
             logger.debug("update: running AFTER_UPDATE")
             engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
         else:
@@ -837,6 +854,49 @@ class HookQuerySetMixin:
 
         return total_updated
 
+    @transaction.atomic
+    def bulk_delete(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
+        """
+        Bulk delete objects in the database.
+        """
+        model_cls = self.model
+
+        if not objs:
+            return 0
+
+        if any(not isinstance(obj, model_cls) for obj in objs):
+            raise TypeError(
+                f"bulk_delete expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
+            )
+
+        logger.debug(
+            f"bulk_delete {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}"
+        )
+
+        # Fire hooks before DB ops
+        if not bypass_hooks:
+            ctx = HookContext(model_cls, bypass_hooks=False)
+            if not bypass_validation:
+                engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
+            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
+        else:
+            ctx = HookContext(model_cls, bypass_hooks=True)
+            logger.debug("bulk_delete bypassed hooks")
+
+        # Use Django's standard delete() method on the queryset
+        pks = [obj.pk for obj in objs if obj.pk is not None]
+        if pks:
+            # Use the base manager to avoid recursion
+            result = self.model._base_manager.filter(pk__in=pks).delete()[0]
+        else:
+            result = 0
+
+        # Fire AFTER_DELETE hooks
+        if not bypass_hooks:
+            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
+
+        return result
+
 
 class HookQuerySet(HookQuerySetMixin, models.QuerySet):
     """

{django_bulk_hooks-0.1.238 → django_bulk_hooks-0.1.239}/django_bulk_hooks/registry.py

@@ -15,7 +15,7 @@ def register_hook(
     key = (model, event)
     hooks = _hooks.setdefault(key, [])
     hooks.append((handler_cls, method_name, condition, priority))
-    # keep sorted by priority
+    # Sort by priority (lower values first)
     hooks.sort(key=lambda x: x[3])
     logger.debug(f"Registered {handler_cls.__name__}.{method_name} for {model.__name__}.{event}")
 
@@ -29,6 +29,13 @@ def get_hooks(model, event):
     return hooks
 
 
+def clear_hooks():
+    """Clear all registered hooks. Useful for testing."""
+    global _hooks
+    _hooks.clear()
+    logger.debug("Cleared all registered hooks")
+
+
 def list_all_hooks():
     """Debug function to list all registered hooks"""
     return _hooks

{django_bulk_hooks-0.1.238 → django_bulk_hooks-0.1.239}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.238"
+version = "0.1.239"
 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"
@@ -16,6 +16,11 @@ packages = [
 python = "^3.11"
 Django = ">=4.0"
 
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+pytest-django = "^4.5.0"
+pytest-cov = "^4.1.0"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

django_bulk_hooks-0.1.238/django_bulk_hooks/__init__.py

@@ -1,4 +0,0 @@
-from django_bulk_hooks.handler import Hook
-from django_bulk_hooks.manager import BulkHookManager
-
-__all__ = ["BulkHookManager", "Hook"]