django-bulk-hooks 0.2.9__py3-none-any.whl → 0.2.93__py3-none-any.whl

django_bulk_hooks/decorators.py

@@ -1,4 +1,5 @@
 import inspect
+import logging
 from functools import wraps
 
 from django.core.exceptions import FieldDoesNotExist
@@ -6,6 +7,8 @@ from django.core.exceptions import FieldDoesNotExist
 from django_bulk_hooks.enums import DEFAULT_PRIORITY
 from django_bulk_hooks.registry import register_hook
 
+logger = logging.getLogger(__name__)
+
 
 def hook(event, *, model, condition=None, priority=DEFAULT_PRIORITY):
     """
@@ -35,10 +38,10 @@ def select_related(*related_fields):
     def decorator(func):
         sig = inspect.signature(func)
 
-        def preload_related(records, *, model_cls=None):
+        def preload_related(records, *, model_cls=None, skip_fields=None):
             if not isinstance(records, list):
                 raise TypeError(
-                    f"@select_related expects a list of model instances, got {type(records)}"
+                    f"@select_related expects a list of model instances, got {type(records)}",
                 )
 
             if not records:
@@ -47,11 +50,14 @@ def select_related(*related_fields):
             if model_cls is None:
                 model_cls = records[0].__class__
 
+            if skip_fields is None:
+                skip_fields = set()
+
             # Validate field notation upfront
             for field in related_fields:
                 if "." in field:
                     raise ValueError(
-                        f"Invalid field notation '{field}'. Use Django ORM __ notation (e.g., 'parent__field')"
+                        f"Invalid field notation '{field}'. Use Django ORM __ notation (e.g., 'parent__field')",
                     )
 
             direct_relation_fields = {}
@@ -70,17 +76,11 @@ def select_related(*related_fields):
                 except (FieldDoesNotExist, AttributeError):
                     continue
 
-                if (
-                    relation_field.is_relation
-                    and not relation_field.many_to_many
-                    and not relation_field.one_to_many
-                ):
+                if relation_field.is_relation and not relation_field.many_to_many and not relation_field.one_to_many:
                     validated_fields.append(field)
                     direct_relation_fields[field] = relation_field
 
-            unsaved_related_ids_by_field = {
-                field: set() for field in direct_relation_fields.keys()
-            }
+            unsaved_related_ids_by_field = {field: set() for field in direct_relation_fields}
 
             saved_ids_to_fetch = []
             for obj in records:
@@ -88,10 +88,7 @@ def select_related(*related_fields):
                     needs_fetch = False
                     if hasattr(obj, "_state") and hasattr(obj._state, "fields_cache"):
                         try:
-                            needs_fetch = any(
-                                field not in obj._state.fields_cache
-                                for field in related_fields
-                            )
+                            needs_fetch = any(field not in obj._state.fields_cache for field in related_fields)
                         except (TypeError, AttributeError):
                             needs_fetch = True
                     else:
@@ -123,14 +120,12 @@ def select_related(*related_fields):
                 if base_manager is not None:
                     try:
                         fetched_saved = base_manager.select_related(
-                            *validated_fields
+                            *validated_fields,
                         ).in_bulk(saved_ids_to_fetch)
                     except Exception:
                         fetched_saved = {}
 
-            fetched_unsaved_by_field = {
-                field: {} for field in direct_relation_fields.keys()
-            }
+            fetched_unsaved_by_field = {field: {} for field in direct_relation_fields}
 
             for field_name, relation_field in direct_relation_fields.items():
                 related_ids = unsaved_related_ids_by_field[field_name]
@@ -161,6 +156,10 @@ def select_related(*related_fields):
                         continue
 
                     for field in related_fields:
+                        # Skip preloading if this relationship conflicts with FK field being updated
+                        if field in skip_fields:
+                            continue
+
                         if fields_cache is not None and field in fields_cache:
                             continue
 
@@ -179,6 +178,10 @@ def select_related(*related_fields):
                     continue
 
                 for field_name, relation_field in direct_relation_fields.items():
+                    # Skip preloading if this relationship conflicts with FK field being updated
+                    if field_name in skip_fields:
+                        continue
+
                     if fields_cache is not None and field_name in fields_cache:
                         continue
 
@@ -198,6 +201,12 @@ def select_related(*related_fields):
                     if fields_cache is not None:
                         fields_cache[field_name] = rel_obj
 
+        def preload_with_skip_fields(records, *, model_cls=None, skip_fields=None):
+            """Wrapper that applies skip_fields logic to the preload function"""
+            if skip_fields is None:
+                skip_fields = set()
+            return preload_related(records, model_cls=model_cls, skip_fields=skip_fields)
+
         @wraps(func)
         def wrapper(*args, **kwargs):
             bound = sig.bind_partial(*args, **kwargs)
@@ -205,18 +214,32 @@ def select_related(*related_fields):
 
             if "new_records" not in bound.arguments:
                 raise TypeError(
-                    "@preload_related requires a 'new_records' argument in the decorated function"
+                    "@preload_related requires a 'new_records' argument in the decorated function",
                 )
 
             new_records = bound.arguments["new_records"]
 
-            model_cls_override = bound.arguments.get("model_cls")
+            if not isinstance(new_records, list):
+                raise TypeError(
+                    f"@select_related expects a list of model instances, got {type(new_records)}",
+                )
 
-            preload_related(new_records, model_cls=model_cls_override)
+            if not new_records:
+                # Empty list, nothing to preload
+                return func(*args, **kwargs)
+
+            # Validate field notation upfront (same as in preload_related)
+            for field in related_fields:
+                if "." in field:
+                    raise ValueError(
+                        f"Invalid field notation '{field}'. Use Django ORM __ notation (e.g., 'parent__field')",
+                    )
 
-            return func(*bound.args, **bound.kwargs)
+            # Don't preload here - let the dispatcher handle it
+            # The dispatcher will call the preload function with skip_fields
+            return func(*args, **kwargs)
 
-        wrapper._select_related_preload = preload_related
+        wrapper._select_related_preload = preload_with_skip_fields
         wrapper._select_related_fields = related_fields
 
         return wrapper
@@ -241,8 +264,27 @@ def bulk_hook(model_cls, event, when=None, priority=None):
             def __init__(self):
                 self.func = func
 
-            def handle(self, new_records=None, old_records=None, **kwargs):
-                return self.func(new_records, old_records, **kwargs)
+            def handle(self, changeset=None, new_records=None, old_records=None, **kwargs):
+                # Support both old and new hook signatures for backward compatibility
+                # Old signature: def hook(self, new_records, old_records, **kwargs)
+                # New signature: def hook(self, changeset, new_records, old_records, **kwargs)
+
+                # Check function signature to determine which format to use
+                import inspect
+
+                sig = inspect.signature(func)
+                params = list(sig.parameters.keys())
+
+                if "changeset" in params:
+                    # New signature with changeset
+                    return self.func(changeset, new_records, old_records, **kwargs)
+                # Old signature without changeset
+                # Only pass changeset in kwargs if the function accepts **kwargs
+                if "kwargs" in params or any(param.startswith("**") for param in sig.parameters):
+                    kwargs["changeset"] = changeset
+                    return self.func(new_records, old_records, **kwargs)
+                # Function doesn't accept **kwargs, just call with positional args
+                return self.func(new_records, old_records)
 
         # Register the hook using the registry
         register_hook(