django-bulk-hooks 0.1.100__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()

django_bulk_hooks/engine.py

@@ -52,31 +52,20 @@ def run(model_cls, event, new_instances, original_instances=None, ctx=None):
         else:
             handler_instance, func = _handler_cache[handler_key]
 
-        # Filter instances based on condition
-        if condition:
-            to_process_new = []
-            to_process_old = []
+        # If no condition, process all instances at once
+        if not condition:
+            func(new_records=new_instances, old_records=original_instances if any(original_instances) else None)
+            continue
 
-            logger.debug(f"Checking condition {condition.__class__.__name__} for {len(new_instances)} instances")
-            for new, original in zip(new_instances, original_instances, strict=True):
-                logger.debug(f"Checking instance {new.__class__.__name__}(pk={new.pk})")
-                try:
-                    matches = condition.check(new, original)
-                    logger.debug(f"Condition check result: {matches}")
-                    if matches:
-                        to_process_new.append(new)
-                        to_process_old.append(original)
-                except Exception as e:
-                    logger.error(f"Error checking condition: {e}")
-                    raise
+        # For conditional hooks, filter instances first
+        to_process_new = []
+        to_process_old = []
 
-            # Only call if we have matching instances
-            if to_process_new:
-                logger.debug(f"Running hook for {len(to_process_new)} matching instances")
-                func(new_records=to_process_new, old_records=to_process_old if any(to_process_old) else None)
-            else:
-                logger.debug("No instances matched condition")
-        else:
-            # No condition, process all instances
-            logger.debug("No condition, processing all instances")
-            func(new_records=new_instances, old_records=original_instances if any(original_instances) else None)
+        for new, original in zip(new_instances, original_instances, strict=True):
+            if 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/handler.py

@@ -1,4 +1,3 @@
-import inspect
 import logging
 import threading
 from collections import deque
@@ -143,21 +142,10 @@ class HookHandler(metaclass=HookMeta):
                 handler = handler_cls()
                 method = getattr(handler, method_name)
 
-                # Inspect the method signature to determine parameter order
-                import inspect
-
-                sig = inspect.signature(method)
-                params = list(sig.parameters.keys())
-
-                # Remove 'self' from params if it exists
-                if params and params[0] == "self":
-                    params = params[1:]
-
-                # Always call with keyword arguments to make order irrelevant
                 try:
                     method(
-                        old_records=old_local,
                         new_records=new_local,
+                        old_records=old_local,
                         **kwargs,
                     )
                 except Exception:

django_bulk_hooks/manager.py

@@ -20,7 +20,7 @@ class BulkHookManager(models.Manager):
     # Default chunk sizes - can be overridden per model
     DEFAULT_CHUNK_SIZE = 200
     DEFAULT_RELATED_CHUNK_SIZE = 500  # Higher for related object fetching
-    
+
     def __init__(self):
         super().__init__()
         self._chunk_size = self.DEFAULT_CHUNK_SIZE
@@ -28,11 +28,16 @@ class BulkHookManager(models.Manager):
         self._prefetch_related_fields = set()
         self._select_related_fields = set()
 
-    def configure(self, chunk_size=None, related_chunk_size=None, 
-                 select_related=None, prefetch_related=None):
+    def configure(
+        self,
+        chunk_size=None,
+        related_chunk_size=None,
+        select_related=None,
+        prefetch_related=None,
+    ):
         """
         Configure bulk operation parameters for this manager.
-        
+
         Args:
             chunk_size: Number of objects to process in each bulk operation chunk
             related_chunk_size: Number of objects to fetch in each related object query
@@ -53,24 +58,24 @@ class BulkHookManager(models.Manager):
         Optimized loading of original instances with smart batching and field selection.
         """
         queryset = self.model.objects.filter(pk__in=pks)
-        
-        # Only select specific fields if provided
-        if fields_to_fetch:
-            queryset = queryset.only('pk', *fields_to_fetch)
-            
+
+        # Only select specific fields if provided and not empty
+        if fields_to_fetch and len(fields_to_fetch) > 0:
+            queryset = queryset.only("pk", *fields_to_fetch)
+
         # Apply configured related field optimizations
         if self._select_related_fields:
             queryset = queryset.select_related(*self._select_related_fields)
         if self._prefetch_related_fields:
             queryset = queryset.prefetch_related(*self._prefetch_related_fields)
-            
+
         # Batch load in chunks to avoid memory issues
         all_originals = []
         for i in range(0, len(pks), self._related_chunk_size):
-            chunk_pks = pks[i:i + self._related_chunk_size]
+            chunk_pks = pks[i : i + self._related_chunk_size]
             chunk_originals = list(queryset.filter(pk__in=chunk_pks))
             all_originals.extend(chunk_originals)
-            
+
         return all_originals
 
     def _get_fields_to_fetch(self, objs, fields):
@@ -79,20 +84,51 @@ class BulkHookManager(models.Manager):
         and what's needed for hooks.
         """
         fields_to_fetch = set(fields)
-        
+
         # Add fields needed by registered hooks
         from django_bulk_hooks.registry import get_hooks
-        hooks = get_hooks(self.model, "before_update") + get_hooks(self.model, "after_update")
-        
+
+        hooks = get_hooks(self.model, "before_update") + get_hooks(
+            self.model, "after_update"
+        )
+
         for handler_cls, method_name, condition, _ in hooks:
             if condition:
                 # If there's a condition, we need all fields it might access
                 fields_to_fetch.update(condition.get_required_fields())
-                
-        return fields_to_fetch
+
+        # Filter out fields that don't exist on the model
+        valid_fields = set()
+        invalid_fields = set()
+        for field_name in fields_to_fetch:
+            try:
+                self.model._meta.get_field(field_name)
+                valid_fields.add(field_name)
+            except Exception as e:
+                # Field doesn't exist, skip it
+                invalid_fields.add(field_name)
+                import logging
+
+                logger = logging.getLogger(__name__)
+                logger.debug(
+                    f"Field '{field_name}' requested by hook condition but doesn't exist on {self.model.__name__}: {e}"
+                )
+                continue
+
+        if invalid_fields:
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.warning(
+                f"Invalid fields requested for {self.model.__name__}: {invalid_fields}. "
+                f"These fields were ignored to prevent errors."
+            )
+
+        return valid_fields
 
     @transaction.atomic
-    def bulk_update(self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs):
+    def bulk_update(
+        self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
+    ):
         if not objs:
             return []
 
@@ -106,14 +142,14 @@ class BulkHookManager(models.Manager):
         if not bypass_hooks:
             # Determine which fields we need to fetch
             fields_to_fetch = self._get_fields_to_fetch(objs, fields)
-            
+
             # Load originals efficiently
             pks = [obj.pk for obj in objs if obj.pk is not None]
             originals = self._load_originals_optimized(pks, fields_to_fetch)
-            
+
             # Create a mapping for quick lookup
             original_map = {obj.pk: obj for obj in originals}
-            
+
             # Align originals with new instances
             aligned_originals = [original_map.get(obj.pk) for obj in objs]
 
@@ -135,7 +171,7 @@ class BulkHookManager(models.Manager):
 
         # Process in chunks
         for i in range(0, len(objs), self._chunk_size):
-            chunk = objs[i:i + self._chunk_size]
+            chunk = objs[i : i + self._chunk_size]
             super(models.Manager, self).bulk_update(chunk, fields, **kwargs)
 
         if not bypass_hooks:
@@ -205,30 +241,32 @@ class BulkHookManager(models.Manager):
             # Process validation in chunks to avoid memory issues
             if not bypass_validation:
                 for i in range(0, len(objs), self._chunk_size):
-                    chunk = objs[i:i + self._chunk_size]
+                    chunk = objs[i : i + self._chunk_size]
                     engine.run(model_cls, VALIDATE_CREATE, chunk, ctx=ctx)
 
             # Process before_create hooks in chunks
             for i in range(0, len(objs), self._chunk_size):
-                chunk = objs[i:i + self._chunk_size]
+                chunk = objs[i : i + self._chunk_size]
                 engine.run(model_cls, BEFORE_CREATE, chunk, ctx=ctx)
 
         # Perform bulk create in chunks
         for i in range(0, len(objs), self._chunk_size):
-            chunk = objs[i:i + self._chunk_size]
+            chunk = objs[i : i + self._chunk_size]
             created_chunk = super(models.Manager, self).bulk_create(chunk, **kwargs)
             result.extend(created_chunk)
 
         if not bypass_hooks:
             # Process after_create hooks in chunks
             for i in range(0, len(result), self._chunk_size):
-                chunk = result[i:i + self._chunk_size]
+                chunk = result[i : i + self._chunk_size]
                 engine.run(model_cls, AFTER_CREATE, chunk, ctx=ctx)
 
         return result
 
     @transaction.atomic
-    def bulk_delete(self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False):
+    def bulk_delete(
+        self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False
+    ):
         if not objs:
             return []
 
@@ -245,8 +283,8 @@ class BulkHookManager(models.Manager):
         if not bypass_hooks:
             # Process hooks in chunks
             for i in range(0, len(objs), chunk_size):
-                chunk = objs[i:i + chunk_size]
-                
+                chunk = objs[i : i + chunk_size]
+
                 if not bypass_validation:
                     engine.run(model_cls, VALIDATE_DELETE, chunk, ctx=ctx)
                 engine.run(model_cls, BEFORE_DELETE, chunk, ctx=ctx)
@@ -254,13 +292,13 @@ class BulkHookManager(models.Manager):
         # Collect PKs and delete in chunks
         pks = [obj.pk for obj in objs if obj.pk is not None]
         for i in range(0, len(pks), chunk_size):
-            chunk_pks = pks[i:i + chunk_size]
+            chunk_pks = pks[i : i + chunk_size]
             model_cls._base_manager.filter(pk__in=chunk_pks).delete()
 
         if not bypass_hooks:
             # Process after_delete hooks in chunks
             for i in range(0, len(objs), chunk_size):
-                chunk = objs[i:i + chunk_size]
+                chunk = objs[i : i + chunk_size]
                 engine.run(model_cls, AFTER_DELETE, chunk, ctx=ctx)
 
         return objs

django_bulk_hooks/models.py

@@ -1,8 +1,4 @@
-import contextlib
-from functools import wraps
-
 from django.db import models, transaction
-from django.db.models.fields.related_descriptors import ForwardManyToOneDescriptor
 
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
@@ -18,6 +14,9 @@ from django_bulk_hooks.constants import (
 from django_bulk_hooks.context import HookContext
 from django_bulk_hooks.engine import run
 from django_bulk_hooks.manager import BulkHookManager
+from django.db.models.fields.related_descriptors import ForwardManyToOneDescriptor
+from functools import wraps
+import contextlib
 
 
 @contextlib.contextmanager
@@ -27,7 +26,7 @@ def patch_foreign_key_behavior():
     RelatedObjectDoesNotExist when accessing an unset foreign key field.
     """
     original_get = ForwardManyToOneDescriptor.__get__
-
+    
     @wraps(original_get)
     def safe_get(self, instance, cls=None):
         if instance is None:
@@ -36,7 +35,7 @@ def patch_foreign_key_behavior():
             return original_get(self, instance, cls)
         except self.RelatedObjectDoesNotExist:
             return None
-
+    
     # Patch the descriptor
     ForwardManyToOneDescriptor.__get__ = safe_get
     try:
@@ -64,7 +63,7 @@ class HookModelMixin(models.Model):
         # Skip hook validation during admin form validation
         # This prevents RelatedObjectDoesNotExist errors when Django hasn't
         # fully set up the object's relationships yet
-        if hasattr(self, "_state") and getattr(self._state, "validating", False):
+        if hasattr(self, '_state') and getattr(self._state, 'validating', False):
             return
 
         # Determine if this is a create or update operation
@@ -81,9 +80,7 @@ class HookModelMixin(models.Model):
                 old_instance = self.__class__.objects.get(pk=self.pk)
                 ctx = HookContext(self.__class__)
                 with patch_foreign_key_behavior():
-                    run(
-                        self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx
-                    )
+                    run(self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx)
             except self.__class__.DoesNotExist:
                 # If the old instance doesn't exist, treat as create
                 ctx = HookContext(self.__class__)
@@ -94,40 +91,24 @@ class HookModelMixin(models.Model):
         is_create = self.pk is None
         ctx = HookContext(self.__class__)
 
-        # Run BEFORE hooks before saving to allow field modifications
+        # Use a single context manager for all hooks
         with patch_foreign_key_behavior():
             if is_create:
                 # For create operations
-                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
                 run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-            else:
-                # For update operations
-                try:
-                    old_instance = self.__class__.objects.get(pk=self.pk)
-                    run(
-                        self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx
-                    )
-                    run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
-                except self.__class__.DoesNotExist:
-                    # If the old instance doesn't exist, treat as create
-                    run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
-                    run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-
-        # Now let Django save with any modifications from BEFORE hooks
-        super().save(*args, **kwargs)
-
-        # Then run AFTER hooks
-        with patch_foreign_key_behavior():
-            if is_create:
-                # For create operations
+                super().save(*args, **kwargs)
                 run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
             else:
                 # For update operations
                 try:
                     old_instance = self.__class__.objects.get(pk=self.pk)
+                    run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
+                    super().save(*args, **kwargs)
                     run(self.__class__, AFTER_UPDATE, [self], [old_instance], ctx=ctx)
                 except self.__class__.DoesNotExist:
                     # If the old instance doesn't exist, treat as create
+                    run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
+                    super().save(*args, **kwargs)
                     run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
 
         return self
@@ -141,5 +122,5 @@ class HookModelMixin(models.Model):
             run(self.__class__, BEFORE_DELETE, [self], ctx=ctx)
             result = super().delete(*args, **kwargs)
             run(self.__class__, AFTER_DELETE, [self], ctx=ctx)
-
+            
         return result

{django_bulk_hooks-0.1.100.dist-info → django_bulk_hooks-0.1.102.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.100
+Version: 0.1.102
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 Home-page: https://github.com/AugendLimited/django-bulk-hooks
 License: MIT
@@ -226,166 +226,3 @@ class EfficientTransactionHandler:
 ```
 
 This approach ensures your hooks are robust and won't fail due to missing related objects, while also being efficient with database queries.
-
-## 🎯 Lambda Conditions and Anonymous Functions
-
-`django-bulk-hooks` supports using anonymous functions (lambda functions) and custom callables as conditions, giving you maximum flexibility for complex filtering logic.
-
-### Using LambdaCondition
-
-The `LambdaCondition` class allows you to use lambda functions or any callable as a condition:
-
-```python
-from django_bulk_hooks import LambdaCondition
-
-class ProductHandler:
-    # Simple lambda condition
-    @hook(Product, "after_create", condition=LambdaCondition(
-        lambda instance: instance.price > 100
-    ))
-    def handle_expensive_products(self, new_records, old_records):
-        """Handle products with price > 100"""
-        for product in new_records:
-            print(f"Expensive product: {product.name}")
-    
-    # Lambda with multiple conditions
-    @hook(Product, "after_update", condition=LambdaCondition(
-        lambda instance: instance.price > 50 and instance.is_active and instance.stock_quantity > 0
-    ))
-    def handle_available_expensive_products(self, new_records, old_records):
-        """Handle active products with price > 50 and stock > 0"""
-        for product in new_records:
-            print(f"Available expensive product: {product.name}")
-    
-    # Lambda comparing with original instance
-    @hook(Product, "after_update", condition=LambdaCondition(
-        lambda instance, original: original and instance.price > original.price * 1.5
-    ))
-    def handle_significant_price_increases(self, new_records, old_records):
-        """Handle products with >50% price increase"""
-        for new_product, old_product in zip(new_records, old_records):
-            if old_product:
-                increase = ((new_product.price - old_product.price) / old_product.price) * 100
-                print(f"Significant price increase: {new_product.name} +{increase:.1f}%")
-```
-
-### Combining Lambda Conditions with Built-in Conditions
-
-You can combine lambda conditions with built-in conditions using the `&` (AND) and `|` (OR) operators:
-
-```python
-from django_bulk_hooks.conditions import HasChanged, IsEqual
-
-class AdvancedProductHandler:
-    # Combine lambda with built-in conditions
-    @hook(Product, "after_update", condition=(
-        HasChanged("price") & 
-        LambdaCondition(lambda instance: instance.price > 100)
-    ))
-    def handle_expensive_price_changes(self, new_records, old_records):
-        """Handle when expensive products have price changes"""
-        for new_product, old_product in zip(new_records, old_records):
-            print(f"Expensive product price changed: {new_product.name}")
-    
-    # Complex combined conditions
-    @hook(Order, "after_update", condition=(
-        LambdaCondition(lambda instance: instance.status == 'completed') &
-        LambdaCondition(lambda instance, original: original and instance.total_amount > original.total_amount)
-    ))
-    def handle_completed_orders_with_increased_amount(self, new_records, old_records):
-        """Handle completed orders that had amount increases"""
-        for new_order, old_order in zip(new_records, old_records):
-            if old_order:
-                increase = new_order.total_amount - old_order.total_amount
-                print(f"Completed order with amount increase: {new_order.customer_name} +${increase}")
-```
-
-### Custom Condition Classes
-
-For reusable logic, you can create custom condition classes:
-
-```python
-from django_bulk_hooks.conditions import HookCondition
-
-class IsPremiumProduct(HookCondition):
-    def check(self, instance, original_instance=None):
-        return (
-            instance.price > 200 and 
-            instance.rating >= 4.0 and 
-            instance.is_active
-        )
-    
-    def get_required_fields(self):
-        return {'price', 'rating', 'is_active'}
-
-class ProductHandler:
-    @hook(Product, "after_create", condition=IsPremiumProduct())
-    def handle_premium_products(self, new_records, old_records):
-        """Handle premium products"""
-        for product in new_records:
-            print(f"Premium product: {product.name}")
-```
-
-### Lambda Conditions with Required Fields
-
-For optimization, you can specify which fields your lambda condition depends on:
-
-```python
-class OptimizedProductHandler:
-    @hook(Product, "after_update", condition=LambdaCondition(
-        lambda instance: instance.price > 100 and instance.category == 'electronics',
-        required_fields={'price', 'category'}
-    ))
-    def handle_expensive_electronics(self, new_records, old_records):
-        """Handle expensive electronics products"""
-        for product in new_records:
-            print(f"Expensive electronics: {product.name}")
-```
-
-### Best Practices for Lambda Conditions
-
-1. **Keep lambdas simple** - Complex logic should be moved to custom condition classes
-2. **Handle None values** - Always check for None before performing operations
-3. **Specify required fields** - This helps with query optimization
-4. **Use descriptive names** - Make your lambda conditions self-documenting
-5. **Test thoroughly** - Lambda conditions can be harder to debug than named functions
-
-```python
-# ✅ GOOD: Simple, clear lambda
-condition = LambdaCondition(lambda instance: instance.price > 100)
-
-# ✅ GOOD: Handles None values
-condition = LambdaCondition(
-    lambda instance: instance.price is not None and instance.price > 100
-)
-
-# ❌ AVOID: Complex logic in lambda
-condition = LambdaCondition(
-    lambda instance: (
-        instance.price > 100 and 
-        instance.category in ['electronics', 'computers'] and
-        instance.stock_quantity > 0 and
-        instance.rating >= 4.0 and
-        instance.is_active and
-        instance.created_at > datetime.now() - timedelta(days=30)
-    )
-)
-
-# ✅ BETTER: Use custom condition class for complex logic
-class IsRecentExpensiveElectronics(HookCondition):
-    def check(self, instance, original_instance=None):
-        return (
-            instance.price > 100 and 
-            instance.category in ['electronics', 'computers'] and
-            instance.stock_quantity > 0 and
-            instance.rating >= 4.0 and
-            instance.is_active and
-            instance.created_at > datetime.now() - timedelta(days=30)
-        )
-    
-    def get_required_fields(self):
-        return {'price', 'category', 'stock_quantity', 'rating', 'is_active', 'created_at'}
-```
-
-## 🔧 Best Practices for Related Objects
-

django_bulk_hooks-0.1.102.dist-info/RECORD

@@ -0,0 +1,16 @@
+django_bulk_hooks/__init__.py,sha256=b5LIO5oWX9ZVITZddma_E_Hosx8Zy9B3_v3z8HmSykg,1132
+django_bulk_hooks/conditions.py,sha256=iCdIrpVciGsmyKgIEjcC0nl_2-mAxay4Tss-ZaenSuY,13735
+django_bulk_hooks/constants.py,sha256=3x1H1fSUUNo0DZONN7GUVDuySZctTR-jtByBHmAIX5w,303
+django_bulk_hooks/context.py,sha256=HVDT73uSzvgrOR6mdXTvsBm3hLOgBU8ant_mB7VlFuM,380
+django_bulk_hooks/decorators.py,sha256=zstmb27dKcOHu3Atg7cauewCTzPvUmq03mzVKJRi56o,7230
+django_bulk_hooks/engine.py,sha256=kWxAggInO8GhmQfSzJrGATAPgnuG7580llpO9NoxHA8,2897
+django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
+django_bulk_hooks/handler.py,sha256=Qpg_zT6SsQiTlhduvzXxPdG6uynjyR2fBjj-R6HZiXI,4861
+django_bulk_hooks/manager.py,sha256=vyIc7ktNbjXCJrqP7SO7lsamBYFrZSCIQBmXSnpK874,12481
+django_bulk_hooks/models.py,sha256=9KvWkmrR0wbTHN6r7-FrSSO9ViS83NvG7iXLBw_iDZs,4793
+django_bulk_hooks/queryset.py,sha256=7lLqhZ-XOYsZ1I3Loxi4Nhz79M8HlTYE413AW8nyeDI,1330
+django_bulk_hooks/registry.py,sha256=Vh78exKYcdZhM27120kQm-iXGOjd_kf9ZUYBZ8eQ2V0,683
+django_bulk_hooks-0.1.102.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.102.dist-info/METADATA,sha256=xpdCGrDTHoLswDQAXL67JvvvUkyEyTkyQfdbRGDiuz8,9040
+django_bulk_hooks-0.1.102.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+django_bulk_hooks-0.1.102.dist-info/RECORD,,

django_bulk_hooks-0.1.100.dist-info/RECORD

@@ -1,16 +0,0 @@
-django_bulk_hooks/__init__.py,sha256=EAWve4HjrrIuPbl8uc1s1ISDM3RPDtwCvTOPRwFpX8w,1392
-django_bulk_hooks/conditions.py,sha256=wDtY90Kv3xjWx8HEA4aAjva8fDDaYegJhn0Eu6G0F60,12150
-django_bulk_hooks/constants.py,sha256=3x1H1fSUUNo0DZONN7GUVDuySZctTR-jtByBHmAIX5w,303
-django_bulk_hooks/context.py,sha256=HVDT73uSzvgrOR6mdXTvsBm3hLOgBU8ant_mB7VlFuM,380
-django_bulk_hooks/decorators.py,sha256=zstmb27dKcOHu3Atg7cauewCTzPvUmq03mzVKJRi56o,7230
-django_bulk_hooks/engine.py,sha256=qSBvBel3pBWVE92ZzgKjMn2ceQpA7FMws2uMXes1MkA,3626
-django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
-django_bulk_hooks/handler.py,sha256=tdDolHAJ_Nd7-RT4s9HRyLtM1UWGjRjP1Y_U6Af32Gg,5325
-django_bulk_hooks/manager.py,sha256=DcVosEA4RS79KSYgw3Z14_a9Sd8CfxNNc5F3eSb8xc0,11459
-django_bulk_hooks/models.py,sha256=U5nCxingZS2sznDjgW8fWo93SisA03WKcGpxxApqhuM,5519
-django_bulk_hooks/queryset.py,sha256=7lLqhZ-XOYsZ1I3Loxi4Nhz79M8HlTYE413AW8nyeDI,1330
-django_bulk_hooks/registry.py,sha256=Vh78exKYcdZhM27120kQm-iXGOjd_kf9ZUYBZ8eQ2V0,683
-django_bulk_hooks-0.1.100.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.100.dist-info/METADATA,sha256=AH1pPY4iPjCTvBY5Vyj4dWYJeU5CELEkVt0uRdiW2bg,15415
-django_bulk_hooks-0.1.100.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-django_bulk_hooks-0.1.100.dist-info/RECORD,,