django-bulk-hooks 0.1.204__tar.gz → 0.1.205__tar.gz

{django_bulk_hooks-0.1.204 → django_bulk_hooks-0.1.205}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.204
+Version: 0.1.205
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.1.204 → django_bulk_hooks-0.1.205}/django_bulk_hooks/decorators.py

@@ -32,82 +32,73 @@ def select_related(*related_fields):
 
     def decorator(func):
         sig = inspect.signature(func)
-        # Precompute the positional index of 'new_records' to avoid per-call binding
-        param_names = list(sig.parameters.keys())
-        new_records_pos = param_names.index("new_records") if "new_records" in param_names else None
-        # Fail fast on nested fields (not supported)
-        for f in related_fields:
-            if "." in f:
-                raise ValueError(f"@select_related does not support nested fields like '{f}'")
 
         @wraps(func)
         def wrapper(*args, **kwargs):
-            # Fast retrieval of new_records without full signature binding
-            new_records = kwargs.get("new_records")
-            if new_records is None and new_records_pos is not None and len(args) > new_records_pos:
-                new_records = args[new_records_pos]
-            if new_records is None:
-                # Fallback for uncommon signatures
-                bound = sig.bind_partial(*args, **kwargs)
-                bound.apply_defaults()
-                if "new_records" not in bound.arguments:
-                    raise TypeError("@select_related requires a 'new_records' argument in the decorated function")
-                new_records = bound.arguments["new_records"]
+            bound = sig.bind_partial(*args, **kwargs)
+            bound.apply_defaults()
+
+            if "new_records" not in bound.arguments:
+                raise TypeError(
+                    "@preload_related requires a 'new_records' argument in the decorated function"
+                )
+
+            new_records = bound.arguments["new_records"]
 
             if not isinstance(new_records, list):
-                raise TypeError(f"@select_related expects a list of model instances, got {type(new_records)}")
+                raise TypeError(
+                    f"@preload_related expects a list of model instances, got {type(new_records)}"
+                )
 
             if not new_records:
                 return func(*args, **kwargs)
 
             # Determine which instances actually need preloading
             model_cls = new_records[0].__class__
-
-            # Validate fields once per model class for this call
-            valid_fields = []
-            for field in related_fields:
-                try:
-                    f = model_cls._meta.get_field(field)
-                    if f.is_relation and not f.many_to_many and not f.one_to_many:
-                        valid_fields.append(field)
-                except FieldDoesNotExist:
-                    continue
-
-            if not valid_fields:
-                return func(*args, **kwargs)
-
             ids_to_fetch = []
             for obj in new_records:
                 if obj.pk is None:
                     continue
-                # If any valid related field is not cached, fetch this object
-                if any(field not in obj._state.fields_cache for field in valid_fields):
+                # 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):
                     ids_to_fetch.append(obj.pk)
 
-            if not ids_to_fetch:
-                return func(*args, **kwargs)
-
-            # Deduplicate while preserving order
-            seen = set()
-            ids_to_fetch = [i for i in ids_to_fetch if not (i in seen or seen.add(i))]
-
-            # Use the base manager to avoid recursion and preload in one query
-            fetched = model_cls._base_manager.select_related(*valid_fields).in_bulk(ids_to_fetch)
+            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)
 
             for obj in new_records:
-                if obj.pk not in fetched:
+                preloaded = fetched.get(obj.pk)
+                if not preloaded:
                     continue
-                preloaded = fetched[obj.pk]
-                for field in valid_fields:
+                for field in related_fields:
                     if field in obj._state.fields_cache:
+                        # don't override values that were explicitly set or already loaded
                         continue
-                    rel_obj = getattr(preloaded, field, None)
-                    if rel_obj is None:
+                    if "." in field:
+                        raise ValueError(
+                            f"@preload_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
+                    except FieldDoesNotExist:
                         continue
-                    setattr(obj, field, rel_obj)
-                    obj._state.fields_cache[field] = rel_obj
 
-            return func(*args, **kwargs)
+                    try:
+                        rel_obj = getattr(preloaded, field)
+                        setattr(obj, field, rel_obj)
+                        obj._state.fields_cache[field] = rel_obj
+                    except AttributeError:
+                        pass
+
+            return func(*bound.args, **bound.kwargs)
 
         return wrapper
 

django_bulk_hooks-0.1.205/django_bulk_hooks/engine.py

@@ -0,0 +1,56 @@
+import logging
+
+from django.core.exceptions import ValidationError
+
+from django_bulk_hooks.registry import get_hooks
+
+logger = logging.getLogger(__name__)
+
+
+def run(model_cls, event, new_records, old_records=None, ctx=None):
+    """
+    Run hooks for a given model, event, and records.
+    """
+    if not new_records:
+        return
+
+    # Get hooks for this model and event
+    hooks = get_hooks(model_cls, event)
+
+    if not hooks:
+        return
+
+    # For BEFORE_* events, run model.clean() first for validation
+    if event.startswith("before_"):
+        for instance in new_records:
+            try:
+                instance.clean()
+            except ValidationError as e:
+                logger.error("Validation failed for %s: %s", instance, e)
+                raise
+
+    # Process hooks
+    for handler_cls, method_name, condition, priority in hooks:
+        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 or condition.check(new, original):
+                to_process_new.append(new)
+                to_process_old.append(original)
+
+        if to_process_new:
+            try:
+                func(
+                    new_records=to_process_new,
+                    old_records=to_process_old if any(to_process_old) else None,
+                )
+            except Exception as e:
+                raise

{django_bulk_hooks-0.1.204 → django_bulk_hooks-0.1.205}/django_bulk_hooks/handler.py

@@ -1,7 +1,6 @@
 import logging
 import threading
 from collections import deque
-from itertools import zip_longest
 
 from django.db import transaction
 
@@ -32,13 +31,6 @@ def get_hook_queue():
     return _hook_context.queue
 
 
-def get_handler_cache():
-    """Thread-local cache for handler instances, scoped per outermost run."""
-    if not hasattr(_hook_context, "handler_cache"):
-        _hook_context.handler_cache = {}
-    return _hook_context.handler_cache
-
-
 class HookContextState:
     @property
     def is_before(self):
@@ -112,8 +104,6 @@ class Hook(metaclass=HookMeta):
             return  # nested call, will be processed by outermost
 
         # only outermost handle will process the queue
-        # initialize a fresh handler cache for this run
-        _hook_context.handler_cache = {}
         while queue:
             cls_, event_, model_, new_, old_, kw_ = queue.popleft()
             cls_._process(event_, model_, new_, old_, **kw_)
@@ -133,56 +123,29 @@ class Hook(metaclass=HookMeta):
         hook_vars.event = event
         hook_vars.model = model
 
-        # Hooks are already kept sorted by priority in the registry
-        hooks = get_hooks(model, event)
+        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
 
         def _execute():
             new_local = new_records or []
             old_local = old_records or []
-            cache = get_handler_cache()
+            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 there's no condition, pass through all records fast
-                if condition is None:
-                    handler = cache.get(handler_cls)
-                    if handler is None:
-                        handler = handler_cls()
-                        cache[handler_cls] = handler
-                    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
-                        )
-                    continue
-
-                # Filter matching records without allocating full boolean list
-                to_process_new = []
-                to_process_old = []
-                for n, o in zip_longest(new_local, old_local, fillvalue=None):
-                    if n is None:
+                if condition is not None:
+                    checks = [
+                        condition.check(n, o) for n, o in zip(new_local, old_local)
+                    ]
+                    if not any(checks):
                         continue
-                    if condition.check(n, o):
-                        to_process_new.append(n)
-                        to_process_old.append(o)
-
-                if not to_process_new:
-                    continue
 
-                handler = cache.get(handler_cls)
-                if handler is None:
-                    handler = handler_cls()
-                    cache[handler_cls] = handler
+                handler = handler_cls()
                 method = getattr(handler, method_name)
+
                 try:
                     method(
-                        new_records=to_process_new,
-                        old_records=to_process_old,
+                        new_records=new_local,
+                        old_records=old_local,
                         **kwargs,
                     )
                 except Exception:
@@ -202,7 +165,3 @@ class Hook(metaclass=HookMeta):
             hook_vars.event = None
             hook_vars.model = None
             hook_vars.depth -= 1
-            # Clear cache only when queue is empty (outermost completion)
-            if not get_hook_queue():
-                if hasattr(_hook_context, "handler_cache"):
-                    _hook_context.handler_cache.clear()