django-bulk-hooks 0.1.204__py3-none-any.whl → 0.1.206__py3-none-any.whl

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/engine.py

@@ -1,7 +1,4 @@
 import logging
-import os
-import time
-from itertools import repeat
 
 from django.core.exceptions import ValidationError
 
@@ -10,20 +7,6 @@ from django_bulk_hooks.registry import get_hooks
 logger = logging.getLogger(__name__)
 
 
-_PROFILE_ENABLED = bool(
-    int(os.getenv("DJANGO_BULK_HOOKS_PROFILE", os.getenv("BULK_HOOKS_PROFILE", "0")))
-)
-_PROFILE_MIN_MS = float(os.getenv("DJANGO_BULK_HOOKS_PROFILE_MIN_MS", "0"))
-
-
-def _log_profile(message: str, duration_ms: float | None = None) -> None:
-    if not _PROFILE_ENABLED:
-        return
-    if duration_ms is not None and duration_ms < _PROFILE_MIN_MS:
-        return
-    print(f"[bulk_hooks.profile] {message}", flush=True)
-
-
 def run(model_cls, event, new_records, old_records=None, ctx=None):
     """
     Run hooks for a given model, event, and records.
@@ -32,96 +15,42 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
         return
 
     # Get hooks for this model and event
-    t0 = time.perf_counter() if _PROFILE_ENABLED else None
     hooks = get_hooks(model_cls, event)
-    if _PROFILE_ENABLED:
-        dt = (time.perf_counter() - t0) * 1000 if t0 is not None else 0.0
-        _log_profile(
-            f"engine.get_hooks model={model_cls.__name__} event={event} took {dt:.2f}ms",
-            dt,
-        )
 
     if not hooks:
         return
 
     # For BEFORE_* events, run model.clean() first for validation
-    if event.startswith("before_") and not getattr(ctx, "skip_model_clean", False):
-        t_clean = time.perf_counter() if _PROFILE_ENABLED else None
+    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
-        if _PROFILE_ENABLED:
-            dt = (time.perf_counter() - t_clean) * 1000 if t_clean is not None else 0.0
-            _log_profile(
-                f"engine.model_clean model={model_cls.__name__} event={event} n={len(new_records)} took {dt:.2f}ms",
-                dt,
-            )
 
     # Process hooks
-    t_hooks_total = time.perf_counter() if _PROFILE_ENABLED else None
     for handler_cls, method_name, condition, priority in hooks:
         handler_instance = handler_cls()
         func = getattr(handler_instance, method_name)
 
-        # Fast path: if no condition, pass-through all records
-        if not condition:
-            try:
-                t_handler = time.perf_counter() if _PROFILE_ENABLED else None
-                func(
-                    new_records=new_records,
-                    old_records=old_records if old_records and any(old_records) else None,
-                )
-                if _PROFILE_ENABLED:
-                    dt = (time.perf_counter() - t_handler) * 1000 if t_handler is not None else 0.0
-                    _log_profile(
-                        f"engine.handler handler={handler_cls.__name__}.{method_name} event={event} n={len(new_records)} took {dt:.2f}ms",
-                        dt,
-                    )
-            except Exception:
-                raise
-            continue
-
-        # Conditional path: select matching records
         to_process_new = []
         to_process_old = []
 
-        t_select = time.perf_counter() if _PROFILE_ENABLED else None
         for new, original in zip(
             new_records,
-            old_records if old_records is not None else repeat(None),
+            old_records or [None] * len(new_records),
+            strict=True,
         ):
-            if condition.check(new, original):
+            if not condition or condition.check(new, original):
                 to_process_new.append(new)
                 to_process_old.append(original)
-        if _PROFILE_ENABLED:
-            dt = (time.perf_counter() - t_select) * 1000 if t_select is not None else 0.0
-            _log_profile(
-                f"engine.select_records handler={handler_cls.__name__}.{method_name} event={event} n={len(new_records)} selected={len(to_process_new)} took {dt:.2f}ms",
-                dt,
-            )
 
         if to_process_new:
             try:
-                t_handler = time.perf_counter() if _PROFILE_ENABLED else None
                 func(
                     new_records=to_process_new,
                     old_records=to_process_old if any(to_process_old) else None,
                 )
-                if _PROFILE_ENABLED:
-                    dt = (time.perf_counter() - t_handler) * 1000 if t_handler is not None else 0.0
-                    _log_profile(
-                        f"engine.handler handler={handler_cls.__name__}.{method_name} event={event} n={len(to_process_new)} took {dt:.2f}ms",
-                        dt,
-                    )
-            except Exception:
+            except Exception as e:
                 raise
-
-    if _PROFILE_ENABLED:
-        dt = (time.perf_counter() - t_hooks_total) * 1000 if t_hooks_total is not None else 0.0
-        _log_profile(
-            f"engine.run model={model_cls.__name__} event={event} n={len(new_records)} took {dt:.2f}ms (handlers only)",
-            dt,
-        )

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()