django-bulk-hooks 0.1.75__tar.gz → 0.1.77__tar.gz

{django_bulk_hooks-0.1.75 → django_bulk_hooks-0.1.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.75
+Version: 0.1.77
 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.75 → django_bulk_hooks-0.1.77}/django_bulk_hooks/conditions.py

@@ -1,12 +1,36 @@
+from django_bulk_hooks.engine import safe_get_related_object
+
+
 def resolve_dotted_attr(instance, dotted_path):
     """
     Recursively resolve a dotted attribute path, e.g., "type.category".
+    This function is designed to work with pre-loaded foreign keys to avoid queries.
     """
+    if instance is None:
+        return None
+    
+    current = instance
     for attr in dotted_path.split("."):
-        if instance is None:
+        if current is None:
             return None
-        instance = getattr(instance, attr, None)
-    return instance
+        
+        # Check if this is a foreign key that might trigger a query
+        if hasattr(current, '_meta') and hasattr(current._meta, 'get_field'):
+            try:
+                field = current._meta.get_field(attr)
+                if field.is_relation and not field.many_to_many and not field.one_to_many:
+                    # For foreign keys, use safe access to prevent RelatedObjectDoesNotExist
+                    current = safe_get_related_object(current, attr)
+                else:
+                    current = getattr(current, attr, None)
+            except Exception:
+                # If field lookup fails, fall back to regular attribute access
+                current = getattr(current, attr, None)
+        else:
+            # Not a model instance, use regular attribute access
+            current = getattr(current, attr, None)
+    
+    return current
 
 
 class HookCondition:

{django_bulk_hooks-0.1.75 → django_bulk_hooks-0.1.77}/django_bulk_hooks/context.py

@@ -10,16 +10,6 @@ def get_hook_queue():
     return _hook_context.queue
 
 
-def is_in_bulk_operation():
-    """Check if we're currently in a bulk operation to prevent recursion."""
-    return getattr(_hook_context, "in_bulk_operation", False)
-
-
-def set_bulk_operation_flag(value):
-    """Set the bulk operation flag to prevent recursion."""
-    _hook_context.in_bulk_operation = value
-
-
 class HookContext:
     def __init__(self, model_cls, metadata=None):
         self.model_cls = model_cls

{django_bulk_hooks-0.1.75 → django_bulk_hooks-0.1.77}/django_bulk_hooks/decorators.py

@@ -24,10 +24,15 @@ def hook(event, *, model, condition=None, priority=DEFAULT_PRIORITY):
 def select_related(*related_fields):
     """
     Decorator that preloads related fields in-place on `new_records`, before the hook logic runs.
+    
+    This decorator provides bulk loading for performance when you explicitly need it.
+    If you don't use this decorator, the framework will automatically detect and load
+    foreign keys only when conditions need them, preserving standard Django behavior.
 
     - Works with instance methods (resolves `self`)
     - Avoids replacing model instances
     - Populates Django's relation cache to avoid extra queries
+    - Provides bulk loading for performance optimization
     """
 
     def decorator(func):
@@ -40,14 +45,14 @@ 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"
+                    "@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)}"
+                    f"@select_related expects a list of model instances, got {type(new_records)}"
                 )
 
             if not new_records:
@@ -56,19 +61,29 @@ def select_related(*related_fields):
             # Determine which instances actually need preloading
             model_cls = new_records[0].__class__
             ids_to_fetch = []
+            instances_without_pk = []
+            
             for obj in new_records:
                 if obj.pk is None:
+                    # For objects without PKs (BEFORE_CREATE), check if foreign key fields are already set
+                    instances_without_pk.append(obj)
                     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):
                     ids_to_fetch.append(obj.pk)
 
+            # Load foreign keys for objects with PKs
             fetched = {}
             if ids_to_fetch:
                 fetched = model_cls.objects.select_related(*related_fields).in_bulk(ids_to_fetch)
 
+            # Apply loaded foreign keys to objects with PKs
             for obj in new_records:
+                if obj.pk is None:
+                    continue
+                    
                 preloaded = fetched.get(obj.pk)
                 if not preloaded:
                     continue
@@ -78,7 +93,7 @@ def select_related(*related_fields):
                         continue
                     if "." in field:
                         raise ValueError(
-                            f"@preload_related does not support nested fields like '{field}'"
+                            f"@select_related does not support nested fields like '{field}'"
                         )
 
                     try:
@@ -96,6 +111,40 @@ def select_related(*related_fields):
                         obj._state.fields_cache[field] = rel_obj
                     except AttributeError:
                         pass
+            
+            # For objects without PKs, ensure foreign key fields are properly set in the cache
+            # This prevents RelatedObjectDoesNotExist when accessing foreign keys
+            for obj in instances_without_pk:
+                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
+                    except FieldDoesNotExist:
+                        continue
+                    
+                    # Check if the foreign key field is set
+                    fk_field_name = f"{field}_id"
+                    if hasattr(obj, fk_field_name) and getattr(obj, fk_field_name) is not None:
+                        # The foreign key ID is set, so we can try to get the related object
+                        try:
+                            rel_obj = getattr(obj, field)
+                            if rel_obj is not None:
+                                # Ensure it's cached to prevent future queries
+                                if not hasattr(obj._state, 'fields_cache'):
+                                    obj._state.fields_cache = {}
+                                obj._state.fields_cache[field] = rel_obj
+                        except Exception:
+                            # If we can't get the related object, that's okay
+                            # The foreign key ID is set, so the relationship exists
+                            pass
 
             return func(*bound.args, **bound.kwargs)
 

django_bulk_hooks-0.1.77/django_bulk_hooks/engine.py

@@ -0,0 +1,93 @@
+import logging
+
+from django.core.exceptions import ValidationError
+from django.db import models
+from django_bulk_hooks.registry import get_hooks
+
+logger = logging.getLogger(__name__)
+
+
+def safe_get_related_object(instance, field_name):
+    """
+    Safely get a related object without raising RelatedObjectDoesNotExist.
+    Returns None if the foreign key field is None or the related object doesn't exist.
+    """
+    if not hasattr(instance, field_name):
+        return None
+    
+    # Get the foreign key field
+    try:
+        field = instance._meta.get_field(field_name)
+        if not field.is_relation or field.many_to_many or field.one_to_many:
+            return getattr(instance, field_name, None)
+    except models.FieldDoesNotExist:
+        return getattr(instance, field_name, None)
+    
+    # Check if the foreign key field is None
+    fk_field_name = f"{field_name}_id"
+    if hasattr(instance, fk_field_name) and getattr(instance, fk_field_name) is None:
+        return None
+    
+    # Try to get the related object, but catch RelatedObjectDoesNotExist
+    try:
+        return getattr(instance, field_name)
+    except field.related_model.RelatedObjectDoesNotExist:
+        return None
+
+
+def safe_get_related_attr(instance, field_name, attr_name=None):
+    """
+    Safely get a related object or its attribute without raising RelatedObjectDoesNotExist.
+    
+    Args:
+        instance: The model instance
+        field_name: The foreign key field name
+        attr_name: Optional attribute name to access on the related object
+    
+    Returns:
+        The related object, the attribute value, or None if not available
+    """
+    related_obj = safe_get_related_object(instance, field_name)
+    if related_obj is None:
+        return None
+    
+    if attr_name is None:
+        return related_obj
+    
+    return getattr(related_obj, attr_name, None)
+
+
+def run(model_cls, event, new_instances, original_instances=None, ctx=None):
+    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_instances:
+            try:
+                instance.clean()
+            except ValidationError as e:
+                logger.error("Validation failed for %s: %s", instance, e)
+                raise
+
+    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_instances,
+            original_instances or [None] * len(new_instances),
+            strict=True,
+        ):
+            if not condition or condition.check(new, original):
+                to_process_new.append(new)
+                to_process_old.append(original)
+
+        if to_process_new:
+            # Call the function with keyword arguments
+            func(new_records=to_process_new, old_records=to_process_old if any(to_process_old) else None)

{django_bulk_hooks-0.1.75 → django_bulk_hooks-0.1.77}/django_bulk_hooks/manager.py

@@ -12,7 +12,7 @@ from django_bulk_hooks.constants import (
     VALIDATE_DELETE,
     VALIDATE_UPDATE,
 )
-from django_bulk_hooks.context import HookContext, is_in_bulk_operation, set_bulk_operation_flag
+from django_bulk_hooks.context import HookContext
 from django_bulk_hooks.queryset import HookQuerySet
 
 
@@ -37,20 +37,10 @@ class BulkHookManager(models.Manager):
             )
 
         if not bypass_hooks:
-            # Check if we're already in a hook context (recursive call)
-            # If so, refetch the current database state like Salesforce does
-            import threading
-
-            if hasattr(threading.current_thread(), "_hook_context"):
-                # We're in a recursive call - refetch current DB state
-                originals = list(
-                    model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
-                )
-            else:
-                # First call - use the passed originals
-                originals = list(
-                    model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
-                )
+            # Load originals for hook comparison
+            originals = list(
+                model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
+            )
 
             ctx = HookContext(model_cls)
 

{django_bulk_hooks-0.1.75 → django_bulk_hooks-0.1.77}/django_bulk_hooks/queryset.py

@@ -1,5 +1,4 @@
 from django.db import models, transaction
-from django_bulk_hooks.context import is_in_bulk_operation
 
 
 class HookQuerySet(models.QuerySet):
@@ -21,7 +20,6 @@ class HookQuerySet(models.QuerySet):
 
         # Load originals for hook comparison
         originals = list(model_cls.objects.filter(pk__in=pks))
-        originals_by_pk = {obj.pk: obj for obj in originals}
 
         # Apply field updates to instances
         for obj in instances:
@@ -36,14 +34,8 @@ class HookQuerySet(models.QuerySet):
         engine.run(model_cls, "before_update", instances, originals, ctx=ctx)
 
         # Use Django's built-in update logic directly
-        # Set flag to prevent recursion during the actual update
-        from django_bulk_hooks.context import set_bulk_operation_flag
-        set_bulk_operation_flag(True)
-        try:
-            queryset = self.model.objects.filter(pk__in=pks)
-            update_count = queryset.update(**kwargs)
-        finally:
-            set_bulk_operation_flag(False)
+        queryset = self.model.objects.filter(pk__in=pks)
+        update_count = queryset.update(**kwargs)
 
         # Run AFTER_UPDATE hooks
         engine.run(model_cls, "after_update", instances, originals, ctx=ctx)

{django_bulk_hooks-0.1.75 → django_bulk_hooks-0.1.77}/pyproject.toml

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

django_bulk_hooks-0.1.75/django_bulk_hooks/engine.py

@@ -1,43 +0,0 @@
-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_instances, original_instances=None, ctx=None):
-    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_instances:
-            try:
-                instance.clean()
-            except ValidationError as e:
-                logger.error("Validation failed for %s: %s", instance, e)
-                raise
-
-    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_instances,
-            original_instances or [None] * len(new_instances),
-            strict=True,
-        ):
-            if not condition or condition.check(new, original):
-                to_process_new.append(new)
-                to_process_old.append(original)
-
-        if to_process_new:
-            # Call the function with keyword arguments
-            func(new_records=to_process_new, old_records=to_process_old if any(to_process_old) else None)