django-bulk-hooks 0.1.83__py3-none-any.whl → 0.2.100__py3-none-any.whl

django_bulk_hooks/conditions.py

@@ -1,351 +1,230 @@
-from django.db import models
-
-
-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 is_field_set(instance, field_name):
-    """
-    Check if a foreign key field is set without raising RelatedObjectDoesNotExist.
-    
-    Args:
-        instance: The model instance
-        field_name: The foreign key field name
-    
-    Returns:
-        True if the field is set, False otherwise
-    """
-    # Check the foreign key ID field first
-    fk_field_name = f"{field_name}_id"
-    if hasattr(instance, fk_field_name):
-        fk_value = getattr(instance, fk_field_name, None)
-        return fk_value is not None
-    
-    # Fallback to checking the field directly
-    try:
-        return getattr(instance, field_name) is not None
-    except Exception:
-        return False
-
-
-def safe_get_related_attr(instance, field_name, attr_name=None):
-    """
-    Safely get a related object or its attribute without raising RelatedObjectDoesNotExist.
-    
-    This is particularly useful in hooks where objects might not have their related
-    fields populated yet (e.g., during bulk_create operations or on unsaved objects).
-    
-    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
-        
-    Example:
-        # Instead of: loan_transaction.status.name (which might fail)
-        # Use: safe_get_related_attr(loan_transaction, 'status', 'name')
-        
-        status_name = safe_get_related_attr(loan_transaction, 'status', 'name')
-        if status_name in {Status.COMPLETE.value, Status.FAILED.value}:
-            # Process the transaction
-            pass
-    """
-    # For unsaved objects, check the foreign key ID field first
-    if instance.pk is None:
-        fk_field_name = f"{field_name}_id"
-        if hasattr(instance, fk_field_name):
-            fk_value = getattr(instance, fk_field_name, None)
-            if fk_value is None:
-                return None
-            # If we have an ID but the object isn't loaded, try to load it
-            try:
-                field = instance._meta.get_field(field_name)
-                if hasattr(field, 'related_model'):
-                    related_obj = field.related_model.objects.get(id=fk_value)
-                    if attr_name is None:
-                        return related_obj
-                    return getattr(related_obj, attr_name, None)
-            except (field.related_model.DoesNotExist, AttributeError):
-                return None
-    
-    # For saved objects or when the above doesn't work, use the original method
-    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 safe_get_related_attr_with_fallback(instance, field_name, attr_name=None, fallback_value=None):
-    """
-    Enhanced version of safe_get_related_attr that provides fallback handling.
-    
-    This function is especially useful for bulk operations where related objects
-    might not be fully loaded or might not exist yet.
-    
-    Args:
-        instance: The model instance
-        field_name: The foreign key field name
-        attr_name: Optional attribute name to access on the related object
-        fallback_value: Value to return if the related object or attribute doesn't exist
-    
-    Returns:
-        The related object, the attribute value, or fallback_value if not available
-    """
-    # First try the standard safe access
-    result = safe_get_related_attr(instance, field_name, attr_name)
-    if result is not None:
-        return result
-    
-    # If that fails, try to get the foreign key ID and fetch the object directly
-    fk_field_name = f"{field_name}_id"
-    if hasattr(instance, fk_field_name):
-        fk_id = getattr(instance, fk_field_name)
-        if fk_id is not None:
-            try:
-                # Get the field to determine the related model
-                field = instance._meta.get_field(field_name)
-                if field.is_relation and not field.many_to_many and not field.one_to_many:
-                    # Try to fetch the related object directly
-                    related_obj = field.related_model.objects.get(pk=fk_id)
-                    if attr_name is None:
-                        return related_obj
-                    return getattr(related_obj, attr_name, fallback_value)
-            except (field.related_model.DoesNotExist, AttributeError):
-                pass
-    
-    return fallback_value
-
-
-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 current is None:
-            return None
-        
-        # 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:
-    def check(self, instance, original_instance=None):
-        raise NotImplementedError
-
-    def __call__(self, instance, original_instance=None):
-        return self.check(instance, original_instance)
-
-    def __and__(self, other):
-        return AndCondition(self, other)
-
-    def __or__(self, other):
-        return OrCondition(self, other)
-
-    def __invert__(self):
-        return NotCondition(self)
-
-
-class IsNotEqual(HookCondition):
-    def __init__(self, field, value, only_on_change=False):
-        self.field = field
-        self.value = value
-        self.only_on_change = only_on_change
-
-    def check(self, instance, original_instance=None):
-        current = resolve_dotted_attr(instance, self.field)
-        if self.only_on_change:
-            if original_instance is None:
-                return False
-            previous = resolve_dotted_attr(original_instance, self.field)
-            return previous == self.value and current != self.value
-        else:
-            return current != self.value
-
-
-class IsEqual(HookCondition):
-    def __init__(self, field, value, only_on_change=False):
-        self.field = field
-        self.value = value
-        self.only_on_change = only_on_change
-
-    def check(self, instance, original_instance=None):
-        current = resolve_dotted_attr(instance, self.field)
-        if self.only_on_change:
-            if original_instance is None:
-                return False
-            previous = resolve_dotted_attr(original_instance, self.field)
-            return previous != self.value and current == self.value
-        else:
-            return current == self.value
-
-
-class HasChanged(HookCondition):
-    def __init__(self, field, has_changed=True):
-        self.field = field
-        self.has_changed = has_changed
-
-    def check(self, instance, original_instance=None):
-        if not original_instance:
-            return False
-        current = resolve_dotted_attr(instance, self.field)
-        previous = resolve_dotted_attr(original_instance, self.field)
-        return (current != previous) == self.has_changed
-
-
-class WasEqual(HookCondition):
-    def __init__(self, field, value, only_on_change=False):
-        """
-        Check if a field's original value was `value`.
-        If only_on_change is True, only return True when the field has changed away from that value.
-        """
-        self.field = field
-        self.value = value
-        self.only_on_change = only_on_change
-
-    def check(self, instance, original_instance=None):
-        if original_instance is None:
-            return False
-        previous = resolve_dotted_attr(original_instance, self.field)
-        if self.only_on_change:
-            current = resolve_dotted_attr(instance, self.field)
-            return previous == self.value and current != self.value
-        else:
-            return previous == self.value
-
-
-class ChangesTo(HookCondition):
-    def __init__(self, field, value):
-        """
-        Check if a field's value has changed to `value`.
-        Only returns True when original value != value and current value == value.
-        """
-        self.field = field
-        self.value = value
-
-    def check(self, instance, original_instance=None):
-        if original_instance is None:
-            return False
-        previous = resolve_dotted_attr(original_instance, self.field)
-        current = resolve_dotted_attr(instance, self.field)
-        return previous != self.value and current == self.value
-
-
-class IsGreaterThan(HookCondition):
-    def __init__(self, field, value):
-        self.field = field
-        self.value = value
-
-    def check(self, instance, original_instance=None):
-        current = resolve_dotted_attr(instance, self.field)
-        return current is not None and current > self.value
-
-
-class IsGreaterThanOrEqual(HookCondition):
-    def __init__(self, field, value):
-        self.field = field
-        self.value = value
-
-    def check(self, instance, original_instance=None):
-        current = resolve_dotted_attr(instance, self.field)
-        return current is not None and current >= self.value
-
-
-class IsLessThan(HookCondition):
-    def __init__(self, field, value):
-        self.field = field
-        self.value = value
-
-    def check(self, instance, original_instance=None):
-        current = resolve_dotted_attr(instance, self.field)
-        return current is not None and current < self.value
-
-
-class IsLessThanOrEqual(HookCondition):
-    def __init__(self, field, value):
-        self.field = field
-        self.value = value
-
-    def check(self, instance, original_instance=None):
-        current = resolve_dotted_attr(instance, self.field)
-        return current is not None and current <= self.value
-
-
-class AndCondition(HookCondition):
-    def __init__(self, cond1, cond2):
-        self.cond1 = cond1
-        self.cond2 = cond2
-
-    def check(self, instance, original_instance=None):
-        return self.cond1.check(instance, original_instance) and self.cond2.check(
-            instance, original_instance
-        )
-
-
-class OrCondition(HookCondition):
-    def __init__(self, cond1, cond2):
-        self.cond1 = cond1
-        self.cond2 = cond2
-
-    def check(self, instance, original_instance=None):
-        return self.cond1.check(instance, original_instance) or self.cond2.check(
-            instance, original_instance
-        )
-
-
-class NotCondition(HookCondition):
-    def __init__(self, cond):
-        self.cond = cond
-
-    def check(self, instance, original_instance=None):
-        return not self.cond.check(instance, original_instance)
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_field_path(instance, field_path):
+    """
+    Recursively resolve a field path using Django's __ notation, e.g., "author__profile__name".
+
+    CRITICAL: For foreign key fields, uses attname to access the ID directly
+    to avoid hooking Django's descriptor protocol which causes N+1 queries.
+    """
+    # For simple field access (no __), use optimized field access
+    if "__" not in field_path:
+        try:
+            # Get the field from the model's meta to check if it's a foreign key
+            field = instance._meta.get_field(field_path)
+            if field.is_relation and not field.many_to_many:
+                # For foreign key fields, use attname to get the ID directly
+                # This avoids hooking Django's descriptor protocol
+                return getattr(instance, field.attname, None)
+            # For regular fields, use normal getattr
+            return getattr(instance, field_path, None)
+        except Exception:
+            # If field lookup fails, fall back to normal getattr
+            return getattr(instance, field_path, None)
+
+    # For paths with __, traverse the relationship chain with FK optimization
+    current_instance = instance
+    for i, attr in enumerate(field_path.split("__")):
+        if current_instance is None:
+            return None
+
+        try:
+            # Check if this is the last attribute and if it's a FK field
+            is_last_attr = i == len(field_path.split("__")) - 1
+            if is_last_attr and hasattr(current_instance, "_meta"):
+                try:
+                    field = current_instance._meta.get_field(attr)
+                    if field.is_relation and not field.many_to_many:
+                        # Use attname for the final FK field access
+                        current_instance = getattr(
+                            current_instance,
+                            field.attname,
+                            None,
+                        )
+                        continue
+                except:
+                    pass  # Fall through to normal getattr
+
+            # Normal getattr for non-FK fields or when FK optimization fails
+            current_instance = getattr(current_instance, attr, None)
+        except Exception:
+            current_instance = None
+
+    return current_instance
+
+
+class HookCondition:
+    def check(self, instance, original_instance=None):
+        raise NotImplementedError
+
+    def __call__(self, instance, original_instance=None):
+        return self.check(instance, original_instance)
+
+    def __and__(self, other):
+        return AndCondition(self, other)
+
+    def __or__(self, other):
+        return OrCondition(self, other)
+
+    def __invert__(self):
+        return NotCondition(self)
+
+
+class IsNotEqual(HookCondition):
+    def __init__(self, field, value, only_on_change=False):
+        self.field = field
+        self.value = value
+        self.only_on_change = only_on_change
+
+    def check(self, instance, original_instance=None):
+        current = resolve_field_path(instance, self.field)
+        if self.only_on_change:
+            if original_instance is None:
+                return False
+            previous = resolve_field_path(original_instance, self.field)
+            return previous == self.value and current != self.value
+        return current != self.value
+
+
+class IsEqual(HookCondition):
+    def __init__(self, field, value, only_on_change=False):
+        self.field = field
+        self.value = value
+        self.only_on_change = only_on_change
+
+    def check(self, instance, original_instance=None):
+        current = resolve_field_path(instance, self.field)
+
+        if self.only_on_change:
+            if original_instance is None:
+                return False
+            previous = resolve_field_path(original_instance, self.field)
+            return previous != self.value and current == self.value
+        return current == self.value
+
+
+class HasChanged(HookCondition):
+    def __init__(self, field, has_changed=True):
+        self.field = field
+        self.has_changed = has_changed
+
+    def check(self, instance, original_instance=None):
+        if not original_instance:
+            return False
+
+        current = resolve_field_path(instance, self.field)
+        previous = resolve_field_path(original_instance, self.field)
+
+        return (current != previous) == self.has_changed
+
+
+class WasEqual(HookCondition):
+    def __init__(self, field, value, only_on_change=False):
+        """
+        Check if a field's original value was `value`.
+        If only_on_change is True, only return True when the field has changed away from that value.
+        """
+        self.field = field
+        self.value = value
+        self.only_on_change = only_on_change
+
+    def check(self, instance, original_instance=None):
+        if original_instance is None:
+            return False
+        previous = resolve_field_path(original_instance, self.field)
+        if self.only_on_change:
+            current = resolve_field_path(instance, self.field)
+            return previous == self.value and current != self.value
+        return previous == self.value
+
+
+class ChangesTo(HookCondition):
+    def __init__(self, field, value):
+        """
+        Check if a field's value has changed to `value`.
+        Only returns True when original value != value and current value == value.
+        """
+        self.field = field
+        self.value = value
+
+    def check(self, instance, original_instance=None):
+        if original_instance is None:
+            return False
+        previous = resolve_field_path(original_instance, self.field)
+        current = resolve_field_path(instance, self.field)
+        return previous != self.value and current == self.value
+
+
+class IsGreaterThan(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
+        self.value = value
+
+    def check(self, instance, original_instance=None):
+        current = resolve_field_path(instance, self.field)
+        return current is not None and current > self.value
+
+
+class IsGreaterThanOrEqual(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
+        self.value = value
+
+    def check(self, instance, original_instance=None):
+        current = resolve_field_path(instance, self.field)
+        return current is not None and current >= self.value
+
+
+class IsLessThan(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
+        self.value = value
+
+    def check(self, instance, original_instance=None):
+        current = resolve_field_path(instance, self.field)
+        return current is not None and current < self.value
+
+
+class IsLessThanOrEqual(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
+        self.value = value
+
+    def check(self, instance, original_instance=None):
+        current = resolve_field_path(instance, self.field)
+        return current is not None and current <= self.value
+
+
+class AndCondition(HookCondition):
+    def __init__(self, cond1, cond2):
+        self.cond1 = cond1
+        self.cond2 = cond2
+
+    def check(self, instance, original_instance=None):
+        return self.cond1.check(instance, original_instance) and self.cond2.check(
+            instance,
+            original_instance,
+        )
+
+
+class OrCondition(HookCondition):
+    def __init__(self, cond1, cond2):
+        self.cond1 = cond1
+        self.cond2 = cond2
+
+    def check(self, instance, original_instance=None):
+        return self.cond1.check(instance, original_instance) or self.cond2.check(
+            instance,
+            original_instance,
+        )
+
+
+class NotCondition(HookCondition):
+    def __init__(self, cond):
+        self.cond = cond
+
+    def check(self, instance, original_instance=None):
+        return not self.cond.check(instance, original_instance)

django_bulk_hooks/constants.py

@@ -7,3 +7,7 @@ AFTER_DELETE = "after_delete"
 VALIDATE_CREATE = "validate_create"
 VALIDATE_UPDATE = "validate_update"
 VALIDATE_DELETE = "validate_delete"
+
+# Default batch size for bulk_update operations to prevent massive SQL statements
+# This prevents PostgreSQL from crashing when updating large datasets with hooks
+DEFAULT_BULK_UPDATE_BATCH_SIZE = 1000

django_bulk_hooks/context.py

@@ -1,16 +1,56 @@
+"""
+Thread-local context management for bulk operations.
+
+This module provides thread-safe storage for operation state like
+bypass_hooks flags and bulk update metadata.
+"""
+
 import threading
-from collections import deque
 
 _hook_context = threading.local()
 
 
-def get_hook_queue():
-    if not hasattr(_hook_context, "queue"):
-        _hook_context.queue = deque()
-    return _hook_context.queue
+def set_bypass_hooks(bypass_hooks):
+    """Set the current bypass_hooks state for the current thread."""
+    _hook_context.bypass_hooks = bypass_hooks
+
+
+def get_bypass_hooks():
+    """Get the current bypass_hooks state for the current thread."""
+    return getattr(_hook_context, "bypass_hooks", False)
+
+
+# Thread-local storage for passing per-object field values from bulk_update -> update
+def set_bulk_update_value_map(value_map):
+    """Store a mapping of {pk: {field_name: value}} for the current thread.
+
+    This allows the internal update() call (hooked by Django's bulk_update)
+    to populate in-memory instances with the concrete values that will be
+    written to the database, instead of Django expression objects like Case/Cast.
+    """
+    _hook_context.bulk_update_value_map = value_map
+
+
+def get_bulk_update_value_map():
+    """Retrieve the mapping {pk: {field_name: value}} for the current thread, if any."""
+    return getattr(_hook_context, "bulk_update_value_map", None)
+
+
+def set_bulk_update_active(active):
+    """Set whether we're currently in a bulk_update operation."""
+    _hook_context.bulk_update_active = active
+
+
+def get_bulk_update_active():
+    """Get whether we're currently in a bulk_update operation."""
+    return getattr(_hook_context, "bulk_update_active", False)
+
+
+def set_bulk_update_batch_size(batch_size):
+    """Store the batch_size for the current bulk_update operation."""
+    _hook_context.bulk_update_batch_size = batch_size
 
 
-class HookContext:
-    def __init__(self, model_cls, metadata=None):
-        self.model_cls = model_cls
-        self.metadata = metadata or {}
+def get_bulk_update_batch_size():
+    """Get the batch_size for the current bulk_update operation."""
+    return getattr(_hook_context, "bulk_update_batch_size", None)