django-bulk-hooks 0.1.76__tar.gz → 0.1.78__tar.gz

{django_bulk_hooks-0.1.76 → django_bulk_hooks-0.1.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.76
+Version: 0.1.78
 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.78/django_bulk_hooks/__init__.py

@@ -0,0 +1,30 @@
+from django_bulk_hooks.constants import (
+    AFTER_CREATE,
+    AFTER_DELETE,
+    AFTER_UPDATE,
+    BEFORE_CREATE,
+    BEFORE_DELETE,
+    BEFORE_UPDATE,
+    VALIDATE_CREATE,
+    VALIDATE_DELETE,
+    VALIDATE_UPDATE,
+)
+from django_bulk_hooks.engine import safe_get_related_object, safe_get_related_attr
+from django_bulk_hooks.handler import HookHandler
+from django_bulk_hooks.models import HookModelMixin
+
+__all__ = [
+    "HookHandler",
+    "HookModelMixin",
+    "BEFORE_CREATE",
+    "AFTER_CREATE",
+    "BEFORE_UPDATE",
+    "AFTER_UPDATE",
+    "BEFORE_DELETE",
+    "AFTER_DELETE",
+    "VALIDATE_CREATE",
+    "VALIDATE_UPDATE",
+    "VALIDATE_DELETE",
+    "safe_get_related_object",
+    "safe_get_related_attr",
+]

{django_bulk_hooks-0.1.76 → django_bulk_hooks-0.1.78}/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.76 → django_bulk_hooks-0.1.78}/django_bulk_hooks/decorators.py

@@ -4,6 +4,7 @@ from functools import wraps
 from django.core.exceptions import FieldDoesNotExist
 from django_bulk_hooks.enums import DEFAULT_PRIORITY
 from django_bulk_hooks.registry import register_hook
+from django_bulk_hooks.engine import safe_get_related_object
 
 
 def hook(event, *, model, condition=None, priority=DEFAULT_PRIORITY):
@@ -24,10 +25,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 +46,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 +62,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 +94,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 +112,35 @@ 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 safely
+                        rel_obj = safe_get_related_object(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
 
             return func(*bound.args, **bound.kwargs)
 

django_bulk_hooks-0.1.78/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.76 → django_bulk_hooks-0.1.78}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.76"
+version = "0.1.78"
 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.76/django_bulk_hooks/__init__.py

@@ -1,4 +0,0 @@
-from django_bulk_hooks.handler import Hook
-from django_bulk_hooks.manager import BulkHookManager
-
-__all__ = ["BulkHookManager", "Hook"]

django_bulk_hooks-0.1.76/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)