django-bulk-hooks 0.1.101__py3-none-any.whl → 0.1.102__py3-none-any.whl

django_bulk_hooks/__init__.py

@@ -1,19 +1,3 @@
-from django_bulk_hooks.conditions import (
-    ChangesTo,
-    HasChanged,
-    IsBlank,
-    IsEqual,
-    IsGreaterThan,
-    IsGreaterThanOrEqual,
-    IsLessThan,
-    IsLessThanOrEqual,
-    IsNotEqual,
-    LambdaCondition,
-    WasEqual,
-    is_field_set,
-    safe_get_related_attr,
-    safe_get_related_object,
-)
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -25,10 +9,20 @@ from django_bulk_hooks.constants import (
     VALIDATE_DELETE,
     VALIDATE_UPDATE,
 )
+from django_bulk_hooks.conditions import (
+    ChangesTo,
+    HasChanged,
+    IsEqual,
+    IsNotEqual,
+    WasEqual,
+    safe_get_related_object,
+    safe_get_related_attr,
+    is_field_set,
+)
 from django_bulk_hooks.decorators import hook, select_related
-from django_bulk_hooks.enums import Priority
 from django_bulk_hooks.handler import HookHandler
 from django_bulk_hooks.models import HookModelMixin
+from django_bulk_hooks.enums import Priority
 
 __all__ = [
     "HookHandler",
@@ -53,10 +47,4 @@ __all__ = [
     "IsEqual",
     "IsNotEqual",
     "WasEqual",
-    "IsBlank",
-    "IsGreaterThan",
-    "IsLessThan",
-    "IsGreaterThanOrEqual",
-    "IsLessThanOrEqual",
-    "LambdaCondition",
 ]

django_bulk_hooks/conditions.py

@@ -8,7 +8,7 @@ def safe_get_related_object(instance, field_name):
     """
     if not hasattr(instance, field_name):
         return None
-
+    
     # Get the foreign key field
     try:
         field = instance._meta.get_field(field_name)
@@ -16,12 +16,12 @@ def safe_get_related_object(instance, field_name):
             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)
@@ -29,25 +29,49 @@ def safe_get_related_object(instance, field_name):
         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
@@ -63,31 +87,96 @@ def safe_get_related_attr(instance, field_name, attr_name=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"):
+                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 is_field_set(instance, field_name):
+def safe_get_related_attr_with_fallback(instance, field_name, attr_name=None, fallback_value=None):
     """
-    Check if a field has been set on a model instance.
+    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
+
 
-    This is useful for checking if a field has been explicitly set,
-    even if it's been set to None.
+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.
     """
-    return hasattr(instance, field_name)
+    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:
@@ -114,94 +203,54 @@ class HookCondition:
         return set()
 
 
-class IsBlank(HookCondition):
-    """
-    Condition that checks if a field is blank (None or empty string).
-    """
-
-    def __init__(self, field_name):
-        self.field_name = field_name
-
-    def check(self, instance, original_instance=None):
-        value = getattr(instance, self.field_name, None)
-        return value is None or value == ""
-
-    def get_required_fields(self):
-        return {self.field_name}
-
-
-class AndCondition(HookCondition):
-    def __init__(self, *conditions):
-        self.conditions = conditions
-
-    def check(self, instance, original_instance=None):
-        return all(c.check(instance, original_instance) for c in self.conditions)
-
-    def get_required_fields(self):
-        fields = set()
-        for condition in self.conditions:
-            fields.update(condition.get_required_fields())
-        return fields
-
-
-class OrCondition(HookCondition):
-    def __init__(self, *conditions):
-        self.conditions = conditions
-
-    def check(self, instance, original_instance=None):
-        return any(c.check(instance, original_instance) for c in self.conditions)
-
-    def get_required_fields(self):
-        fields = set()
-        for condition in self.conditions:
-            fields.update(condition.get_required_fields())
-        return fields
-
-
-class NotCondition(HookCondition):
-    def __init__(self, condition):
-        self.condition = condition
+class IsEqual(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
+        self.value = value
 
     def check(self, instance, original_instance=None):
-        return not self.condition.check(instance, original_instance)
+        current_value = resolve_dotted_attr(instance, self.field)
+        return current_value == self.value
 
     def get_required_fields(self):
-        return self.condition.get_required_fields()
+        return {self.field.split('.')[0]}
 
 
-class IsEqual(HookCondition):
-    def __init__(self, field_name, value):
-        self.field_name = field_name
+class IsNotEqual(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
         self.value = value
 
     def check(self, instance, original_instance=None):
-        return getattr(instance, self.field_name, None) == self.value
+        current_value = resolve_dotted_attr(instance, self.field)
+        return current_value != self.value
 
     def get_required_fields(self):
-        return {self.field_name}
+        return {self.field.split('.')[0]}
 
 
 class WasEqual(HookCondition):
-    def __init__(self, field_name, value):
-        self.field_name = field_name
+    def __init__(self, field, value):
+        self.field = field
         self.value = value
 
     def check(self, instance, original_instance=None):
         if original_instance is None:
             return False
-        return getattr(original_instance, self.field_name, None) == self.value
+        original_value = resolve_dotted_attr(original_instance, self.field)
+        return original_value == self.value
 
     def get_required_fields(self):
-        return {self.field_name}
+        return {self.field.split('.')[0]}
 
 
 class HasChanged(HookCondition):
-    def __init__(self, field_name, has_changed=True):
+    def __init__(self, field, has_changed=True):
         """
         Check if a field's value has changed or remained the same.
-
+        
         Args:
-            field_name: The field name to check
+            field: The field name to check
             has_changed: If True (default), condition passes when field has changed.
                         If False, condition passes when field has remained the same.
                         This is useful for:
@@ -210,149 +259,118 @@ class HasChanged(HookCondition):
                         - Ensuring critical fields remain constant
                         - State machine validations
         """
-        self.field_name = field_name
+        self.field = field
         self.has_changed = has_changed
 
     def check(self, instance, original_instance=None):
         if original_instance is None:
             # For new instances:
-            # - If we're checking for changes (has_changed=True), return True since it's a new record
-            # - If we're checking for stability (has_changed=False), return False since it's technically changed from nothing
-            return self.has_changed
-
-        current_value = getattr(instance, self.field_name, None)
-        original_value = getattr(original_instance, self.field_name, None)
+            # - If we're checking for changes (has_changed=True), return False since there's no change yet
+            # - If we're checking for stability (has_changed=False), return True since it's technically unchanged
+            return not self.has_changed
+            
+        current_value = resolve_dotted_attr(instance, self.field)
+        original_value = resolve_dotted_attr(original_instance, self.field)
         return (current_value != original_value) == self.has_changed
 
     def get_required_fields(self):
-        return {self.field_name}
+        return {self.field.split('.')[0]}
 
 
 class ChangesTo(HookCondition):
-    def __init__(self, field_name, value):
-        self.field_name = field_name
+    def __init__(self, field, value):
+        self.field = field
         self.value = value
 
     def check(self, instance, original_instance=None):
         if original_instance is None:
-            return getattr(instance, self.field_name, None) == self.value
-        return getattr(instance, self.field_name, None) == self.value and getattr(
-            instance, self.field_name, None
-        ) != getattr(original_instance, self.field_name, None)
+            current_value = resolve_dotted_attr(instance, self.field)
+            return current_value == self.value
+
+        current_value = resolve_dotted_attr(instance, self.field)
+        original_value = resolve_dotted_attr(original_instance, self.field)
+        return current_value == self.value and current_value != original_value
 
     def get_required_fields(self):
-        return {self.field_name}
+        return {self.field.split('.')[0]}
 
 
-class IsNotEqual(HookCondition):
-    def __init__(self, field_name, value):
-        self.field_name = field_name
+class IsGreaterThan(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
         self.value = value
 
     def check(self, instance, original_instance=None):
-        return getattr(instance, self.field_name, None) != self.value
-
-    def get_required_fields(self):
-        return {self.field_name}
+        current = resolve_dotted_attr(instance, self.field)
+        return current is not None and current > self.value
 
 
-class IsGreaterThan(HookCondition):
-    def __init__(self, field_name, value):
-        self.field_name = field_name
+class IsGreaterThanOrEqual(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
         self.value = value
 
     def check(self, instance, original_instance=None):
-        field_value = getattr(instance, self.field_name, None)
-        if field_value is None:
-            return False
-        return field_value > self.value
-
-    def get_required_fields(self):
-        return {self.field_name}
+        current = resolve_dotted_attr(instance, self.field)
+        return current is not None and current >= self.value
 
 
 class IsLessThan(HookCondition):
-    def __init__(self, field_name, value):
-        self.field_name = field_name
+    def __init__(self, field, value):
+        self.field = field
         self.value = value
 
     def check(self, instance, original_instance=None):
-        field_value = getattr(instance, self.field_name, None)
-        if field_value is None:
-            return False
-        return field_value < self.value
-
-    def get_required_fields(self):
-        return {self.field_name}
+        current = resolve_dotted_attr(instance, self.field)
+        return current is not None and current < self.value
 
 
-class IsGreaterThanOrEqual(HookCondition):
-    def __init__(self, field_name, value):
-        self.field_name = field_name
+class IsLessThanOrEqual(HookCondition):
+    def __init__(self, field, value):
+        self.field = field
         self.value = value
 
     def check(self, instance, original_instance=None):
-        field_value = getattr(instance, self.field_name, None)
-        if field_value is None:
-            return False
-        return field_value >= self.value
+        current = resolve_dotted_attr(instance, self.field)
+        return current is not None and current <= self.value
 
-    def get_required_fields(self):
-        return {self.field_name}
 
-
-class IsLessThanOrEqual(HookCondition):
-    def __init__(self, field_name, value):
-        self.field_name = field_name
-        self.value = value
+class AndCondition(HookCondition):
+    def __init__(self, condition1, condition2):
+        self.condition1 = condition1
+        self.condition2 = condition2
 
     def check(self, instance, original_instance=None):
-        field_value = getattr(instance, self.field_name, None)
-        if field_value is None:
-            return False
-        return field_value <= self.value
+        return (
+            self.condition1.check(instance, original_instance)
+            and self.condition2.check(instance, original_instance)
+        )
 
     def get_required_fields(self):
-        return {self.field_name}
+        return self.condition1.get_required_fields() | self.condition2.get_required_fields()
 
 
-class LambdaCondition(HookCondition):
-    """
-    A condition that uses a lambda function or any callable.
-
-    This makes it easy to create custom conditions inline without defining
-    a full class.
-
-    Example:
-        # Simple lambda condition
-        condition = LambdaCondition(lambda instance: instance.price > 100)
+class OrCondition(HookCondition):
+    def __init__(self, condition1, condition2):
+        self.condition1 = condition1
+        self.condition2 = condition2
 
-        # Lambda with original instance
-        condition = LambdaCondition(
-            lambda instance, original: instance.price > original.price
+    def check(self, instance, original_instance=None):
+        return (
+            self.condition1.check(instance, original_instance)
+            or self.condition2.check(instance, original_instance)
         )
 
-        # Using in a hook
-        @hook(Product, "after_update", condition=LambdaCondition(
-            lambda instance: instance.price > 100 and instance.is_active
-        ))
-        def handle_expensive_active_products(self, new_records, old_records):
-            pass
-    """
+    def get_required_fields(self):
+        return self.condition1.get_required_fields() | self.condition2.get_required_fields()
 
-    def __init__(self, func, required_fields=None):
-        """
-        Initialize with a callable function.
 
-        Args:
-            func: A callable that takes (instance, original_instance=None) and returns bool
-            required_fields: Optional set of field names this condition depends on
-        """
-        self.func = func
-        self._required_fields = required_fields or set()
+class NotCondition(HookCondition):
+    def __init__(self, condition):
+        self.condition = condition
 
     def check(self, instance, original_instance=None):
-        return self.func(instance, original_instance)
+        return not self.condition.check(instance, original_instance)
 
     def get_required_fields(self):
-        return self._required_fields
+        return self.condition.get_required_fields()