django-bulk-hooks 0.1.202__tar.gz → 0.1.203__tar.gz

{django_bulk_hooks-0.1.202 → django_bulk_hooks-0.1.203}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.202
+Version: 0.1.203
 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.202 → django_bulk_hooks-0.1.203}/django_bulk_hooks/decorators.py

@@ -32,73 +32,82 @@ 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):
-            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"]
+            # 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"]
 
             if not isinstance(new_records, list):
-                raise TypeError(
-                    f"@preload_related expects a list of model instances, got {type(new_records)}"
-                )
+                raise TypeError(f"@select_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 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 valid related field is not cached, fetch this object
+                if any(field not in obj._state.fields_cache for field in valid_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)
+            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)
 
             for obj in new_records:
-                preloaded = fetched.get(obj.pk)
-                if not preloaded:
+                if obj.pk not in fetched:
                     continue
-                for field in related_fields:
+                preloaded = fetched[obj.pk]
+                for field in valid_fields:
                     if field in obj._state.fields_cache:
-                        # 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}'"
-                        )
-
-                    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:
+                    rel_obj = getattr(preloaded, field, None)
+                    if rel_obj is None:
                         continue
+                    setattr(obj, field, rel_obj)
+                    obj._state.fields_cache[field] = rel_obj
 
-                    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 func(*args, **kwargs)
 
         return wrapper
 

{django_bulk_hooks-0.1.202 → django_bulk_hooks-0.1.203}/django_bulk_hooks/engine.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import time
+from itertools import repeat
 
 from django.core.exceptions import ValidationError
 
@@ -12,11 +13,15 @@ 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) -> None:
-    if _PROFILE_ENABLED:
-        print(f"[bulk_hooks.profile] {message}", flush=True)
+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):
@@ -30,15 +35,17 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
     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 {(time.perf_counter()-t0)*1000:.2f}ms"
+            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_"):
+    if event.startswith("before_") and not getattr(ctx, "skip_model_clean", False):
         t_clean = time.perf_counter() if _PROFILE_ENABLED else None
         for instance in new_records:
             try:
@@ -47,8 +54,10 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
                 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 {(time.perf_counter()-t_clean)*1000:.2f}ms"
+                f"engine.model_clean model={model_cls.__name__} event={event} n={len(new_records)} took {dt:.2f}ms",
+                dt,
             )
 
     # Process hooks
@@ -57,21 +66,42 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
         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 or [None] * len(new_records),
+            old_records if old_records is not None else repeat(None),
             strict=True,
         ):
-            if not condition or condition.check(new, original):
+            if 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 {(time.perf_counter()-t_select)*1000:.2f}ms"
+                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:
@@ -82,13 +112,17 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
                     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 {(time.perf_counter()-t_handler)*1000:.2f}ms"
+                        f"engine.handler handler={handler_cls.__name__}.{method_name} event={event} n={len(to_process_new)} took {dt:.2f}ms",
+                        dt,
                     )
-            except Exception as e:
+            except Exception:
                 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 {(time.perf_counter()-t_hooks_total)*1000:.2f}ms (handlers only)"
+            f"engine.run model={model_cls.__name__} event={event} n={len(new_records)} took {dt:.2f}ms (handlers only)",
+            dt,
         )

{django_bulk_hooks-0.1.202 → django_bulk_hooks-0.1.203}/django_bulk_hooks/handler.py

@@ -1,6 +1,7 @@
 import logging
 import threading
 from collections import deque
+from itertools import zip_longest
 
 from django.db import transaction
 
@@ -31,6 +32,13 @@ 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):
@@ -104,6 +112,8 @@ 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_)
@@ -123,29 +133,56 @@ class Hook(metaclass=HookMeta):
         hook_vars.event = event
         hook_vars.model = model
 
-        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
+        # Hooks are already kept sorted by priority in the registry
+        hooks = get_hooks(model, 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))
+            cache = get_handler_cache()
 
             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):
+                # 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:
                         continue
+                    if condition.check(n, o):
+                        to_process_new.append(n)
+                        to_process_old.append(o)
 
-                handler = handler_cls()
-                method = getattr(handler, method_name)
+                if not to_process_new:
+                    continue
 
+                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,
+                        new_records=to_process_new,
+                        old_records=to_process_old,
                         **kwargs,
                     )
                 except Exception:
@@ -165,3 +202,7 @@ 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()

{django_bulk_hooks-0.1.202 → django_bulk_hooks-0.1.203}/django_bulk_hooks/queryset.py

@@ -30,6 +30,8 @@ class HookQuerySetMixin:
     _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"))
+    _DEFAULT_BATCH_SIZE = int(os.getenv("DJANGO_BULK_HOOKS_DEFAULT_BATCH_SIZE", "0")) or None
 
     @classmethod
     def _profile_enabled(cls):
@@ -54,7 +56,8 @@ class HookQuerySetMixin:
             elapsed_ms = (time.perf_counter() - start) * 1000.0
             model_str = f" model={model_cls.__name__}" if model_cls is not None else ""
             extra_str = f" {extra}" if extra else ""
-            cls._profile_log(f"{label}{model_str}{extra_str} took {elapsed_ms:.2f}ms")
+            if elapsed_ms >= cls._PROFILE_MIN_MS:
+                cls._profile_log(f"{label}{model_str}{extra_str} took {elapsed_ms:.2f}ms")
     
     @transaction.atomic
     def delete(self):
@@ -156,6 +159,10 @@ class HookQuerySetMixin:
         # PostgreSQL via the RETURNING ID clause. It should be possible for
         # Oracle as well, but the semantics for extracting the primary keys is
         # trickier so it's not done yet.
+        # Apply default batch size from env if not provided
+        if batch_size is None and self._DEFAULT_BATCH_SIZE:
+            batch_size = self._DEFAULT_BATCH_SIZE
+
         if batch_size is not None and batch_size <= 0:
             raise ValueError("Batch size must be a positive integer.")
 
@@ -186,6 +193,8 @@ class HookQuerySetMixin:
                 if not bypass_validation:
                     with self._profile_step("hooks.validate_create", model_cls, extra=f"n={len(objs)}"):
                         engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
+                    # Skip model.clean in BEFORE_* since we just validated above
+                    setattr(ctx, "skip_model_clean", True)
                 with self._profile_step("hooks.before_create", model_cls, extra=f"n={len(objs)}"):
                     engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
 
@@ -270,6 +279,8 @@ class HookQuerySetMixin:
                 if not bypass_validation:
                     with self._profile_step("hooks.validate_update", model_cls, extra=f"n={len(objs)}"):
                         engine.run(model_cls, VALIDATE_UPDATE, objs, originals, ctx=ctx)
+                    # Skip model.clean in BEFORE_* since we just validated above
+                    setattr(ctx, "skip_model_clean", True)
 
                 # Then run business logic hooks
                 with self._profile_step("hooks.before_update", model_cls, extra=f"n={len(objs)}"):
@@ -308,6 +319,9 @@ class HookQuerySetMixin:
                 for k, v in kwargs.items()
                 if k not in ["bypass_hooks", "bypass_validation"]
             }
+            # Apply default batch size if not provided
+            if "batch_size" not in django_kwargs and self._DEFAULT_BATCH_SIZE:
+                django_kwargs["batch_size"] = self._DEFAULT_BATCH_SIZE
             with self._profile_step("bulk_update.django", model_cls, extra=f"n={len(objs)} fields={fields}"):
                 result = super().bulk_update(objs, fields, **django_kwargs)
 

{django_bulk_hooks-0.1.202 → django_bulk_hooks-0.1.203}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.202"
+version = "0.1.203"
 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"