django-bulk-hooks 0.2.61__tar.gz → 0.2.63__tar.gz

{django_bulk_hooks-0.2.61 → django_bulk_hooks-0.2.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.61
+Version: 0.2.63
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.2.61 → django_bulk_hooks-0.2.63}/django_bulk_hooks/changeset.py

@@ -1,211 +1,214 @@
-"""
-ChangeSet and RecordChange classes for Salesforce-style hook context.
-
-Provides a first-class abstraction for tracking changes in bulk operations,
-similar to Salesforce's Hook.new, Hook.old, and Hook.newMap.
-"""
-
-
-class RecordChange:
-    """
-    Represents a single record change with old/new state.
-
-    Similar to accessing Hook.newMap.get(id) in Salesforce, but with
-    additional conveniences like O(1) field change detection.
-    """
-
-    def __init__(self, new_record, old_record=None, changed_fields=None):
-        """
-        Initialize a RecordChange.
-
-        Args:
-            new_record: The new/current state of the record
-            old_record: The old/previous state of the record (None for creates)
-            changed_fields: Optional pre-computed set of changed field names.
-                          If None, will be computed lazily on first access.
-        """
-        self.new_record = new_record
-        self.old_record = old_record
-        self._changed_fields = changed_fields
-        self._pk = getattr(new_record, "pk", None) if new_record else None
-
-    @property
-    def pk(self):
-        """Primary key of the record."""
-        return self._pk
-
-    @property
-    def changed_fields(self):
-        """
-        Set of field names that have changed.
-
-        Computed lazily on first access and cached for O(1) subsequent checks.
-        """
-        if self._changed_fields is None:
-            self._changed_fields = self._compute_changed_fields()
-        return self._changed_fields
-
-    def has_changed(self, field_name):
-        """
-        O(1) check if a specific field has changed.
-
-        Args:
-            field_name: Name of the field to check
-
-        Returns:
-            True if the field value changed, False otherwise
-        """
-        return field_name in self.changed_fields
-
-    def get_old_value(self, field_name):
-        """
-        Get the old value for a field.
-
-        Args:
-            field_name: Name of the field
-
-        Returns:
-            The old value, or None if no old record exists
-        """
-        if self.old_record is None:
-            return None
-        return getattr(self.old_record, field_name, None)
-
-    def get_new_value(self, field_name):
-        """
-        Get the new value for a field.
-
-        Args:
-            field_name: Name of the field
-
-        Returns:
-            The new value
-        """
-        return getattr(self.new_record, field_name, None)
-
-    def _compute_changed_fields(self):
-        """
-        Compute which fields have changed between old and new records.
-
-        Uses Django's field.get_prep_value() for proper comparison that
-        handles database-level transformations.
-
-        Returns:
-            Set of field names that have changed
-        """
-        if self.old_record is None:
-            return set()
-
-        # Import here to avoid circular dependency
-        from .operations.field_utils import get_changed_fields
-
-        model_cls = self.new_record.__class__
-        return get_changed_fields(self.old_record, self.new_record, model_cls)
-
-
-class ChangeSet:
-    """
-    Collection of RecordChanges for a bulk operation.
-
-    Similar to Salesforce's Hook context (Hook.new, Hook.old, Hook.newMap),
-    but enhanced for Python's bulk operations paradigm with O(1) lookups and
-    additional metadata.
-    """
-
-    def __init__(self, model_cls, changes, operation_type, operation_meta=None):
-        """
-        Initialize a ChangeSet.
-
-        Args:
-            model_cls: The Django model class
-            changes: List of RecordChange instances
-            operation_type: Type of operation ('create', 'update', 'delete')
-            operation_meta: Optional dict of additional metadata (e.g., update_kwargs)
-        """
-        self.model_cls = model_cls
-        self.changes = changes  # List[RecordChange]
-        self.operation_type = operation_type
-        self.operation_meta = operation_meta or {}
-
-        # Build PK -> RecordChange map for O(1) lookups (like Hook.newMap)
-        self._pk_to_change = {c.pk: c for c in changes if c.pk is not None}
-
-    @property
-    def new_records(self):
-        """
-        List of new/current record states.
-
-        Similar to Hook.new in Salesforce.
-        """
-        return [c.new_record for c in self.changes if c.new_record is not None]
-
-    @property
-    def old_records(self):
-        """
-        List of old/previous record states.
-
-        Similar to Hook.old in Salesforce.
-        Only includes records that have old states (excludes creates).
-        """
-        return [c.old_record for c in self.changes if c.old_record is not None]
-
-    def has_field_changed(self, pk, field_name):
-        """
-        O(1) check if a field changed for a specific record.
-
-        Args:
-            pk: Primary key of the record
-            field_name: Name of the field to check
-
-        Returns:
-            True if the field changed, False otherwise
-        """
-        change = self._pk_to_change.get(pk)
-        return change.has_changed(field_name) if change else False
-
-    def get_old_value(self, pk, field_name):
-        """
-        Get the old value for a specific record and field.
-
-        Args:
-            pk: Primary key of the record
-            field_name: Name of the field
-
-        Returns:
-            The old value, or None if not found
-        """
-        change = self._pk_to_change.get(pk)
-        return change.get_old_value(field_name) if change else None
-
-    def get_new_value(self, pk, field_name):
-        """
-        Get the new value for a specific record and field.
-
-        Args:
-            pk: Primary key of the record
-            field_name: Name of the field
-
-        Returns:
-            The new value, or None if not found
-        """
-        change = self._pk_to_change.get(pk)
-        return change.get_new_value(field_name) if change else None
-
-    def chunk(self, chunk_size):
-        """
-        Split ChangeSet into smaller chunks for memory-efficient processing.
-
-        Useful for processing very large bulk operations without loading
-        all data into memory at once.
-
-        Args:
-            chunk_size: Number of changes per chunk
-
-        Yields:
-            ChangeSet instances, each with up to chunk_size changes
-        """
-        for i in range(0, len(self.changes), chunk_size):
-            chunk_changes = self.changes[i : i + chunk_size]
-            yield ChangeSet(
-                self.model_cls, chunk_changes, self.operation_type, self.operation_meta,
-            )
+"""
+ChangeSet and RecordChange classes for Salesforce-style hook context.
+
+Provides a first-class abstraction for tracking changes in bulk operations,
+similar to Salesforce's Hook.new, Hook.old, and Hook.newMap.
+"""
+
+
+class RecordChange:
+    """
+    Represents a single record change with old/new state.
+
+    Similar to accessing Hook.newMap.get(id) in Salesforce, but with
+    additional conveniences like O(1) field change detection.
+    """
+
+    def __init__(self, new_record, old_record=None, changed_fields=None):
+        """
+        Initialize a RecordChange.
+
+        Args:
+            new_record: The new/current state of the record
+            old_record: The old/previous state of the record (None for creates)
+            changed_fields: Optional pre-computed set of changed field names.
+                          If None, will be computed lazily on first access.
+        """
+        self.new_record = new_record
+        self.old_record = old_record
+        self._changed_fields = changed_fields
+        self._pk = getattr(new_record, "pk", None) if new_record else None
+
+    @property
+    def pk(self):
+        """Primary key of the record."""
+        return self._pk
+
+    @property
+    def changed_fields(self):
+        """
+        Set of field names that have changed.
+
+        Computed lazily on first access and cached for O(1) subsequent checks.
+        """
+        if self._changed_fields is None:
+            self._changed_fields = self._compute_changed_fields()
+        return self._changed_fields
+
+    def has_changed(self, field_name):
+        """
+        O(1) check if a specific field has changed.
+
+        Args:
+            field_name: Name of the field to check
+
+        Returns:
+            True if the field value changed, False otherwise
+        """
+        return field_name in self.changed_fields
+
+    def get_old_value(self, field_name):
+        """
+        Get the old value for a field.
+
+        Args:
+            field_name: Name of the field
+
+        Returns:
+            The old value, or None if no old record exists
+        """
+        if self.old_record is None:
+            return None
+        return getattr(self.old_record, field_name, None)
+
+    def get_new_value(self, field_name):
+        """
+        Get the new value for a field.
+
+        Args:
+            field_name: Name of the field
+
+        Returns:
+            The new value
+        """
+        return getattr(self.new_record, field_name, None)
+
+    def _compute_changed_fields(self):
+        """
+        Compute which fields have changed between old and new records.
+
+        Uses Django's field.get_prep_value() for proper comparison that
+        handles database-level transformations.
+
+        Returns:
+            Set of field names that have changed
+        """
+        if self.old_record is None:
+            return set()
+
+        # Import here to avoid circular dependency
+        from .operations.field_utils import get_changed_fields
+
+        model_cls = self.new_record.__class__
+        return get_changed_fields(self.old_record, self.new_record, model_cls)
+
+
+class ChangeSet:
+    """
+    Collection of RecordChanges for a bulk operation.
+
+    Similar to Salesforce's Hook context (Hook.new, Hook.old, Hook.newMap),
+    but enhanced for Python's bulk operations paradigm with O(1) lookups and
+    additional metadata.
+    """
+
+    def __init__(self, model_cls, changes, operation_type, operation_meta=None):
+        """
+        Initialize a ChangeSet.
+
+        Args:
+            model_cls: The Django model class
+            changes: List of RecordChange instances
+            operation_type: Type of operation ('create', 'update', 'delete')
+            operation_meta: Optional dict of additional metadata (e.g., update_kwargs)
+        """
+        self.model_cls = model_cls
+        self.changes = changes  # List[RecordChange]
+        self.operation_type = operation_type
+        self.operation_meta = operation_meta or {}
+
+        # Build PK -> RecordChange map for O(1) lookups (like Hook.newMap)
+        self._pk_to_change = {c.pk: c for c in changes if c.pk is not None}
+
+    @property
+    def new_records(self):
+        """
+        List of new/current record states.
+
+        Similar to Hook.new in Salesforce.
+        """
+        return [c.new_record for c in self.changes if c.new_record is not None]
+
+    @property
+    def old_records(self):
+        """
+        List of old/previous record states.
+
+        Similar to Hook.old in Salesforce.
+        Only includes records that have old states (excludes creates).
+        """
+        return [c.old_record for c in self.changes if c.old_record is not None]
+
+    def has_field_changed(self, pk, field_name):
+        """
+        O(1) check if a field changed for a specific record.
+
+        Args:
+            pk: Primary key of the record
+            field_name: Name of the field to check
+
+        Returns:
+            True if the field changed, False otherwise
+        """
+        change = self._pk_to_change.get(pk)
+        return change.has_changed(field_name) if change else False
+
+    def get_old_value(self, pk, field_name):
+        """
+        Get the old value for a specific record and field.
+
+        Args:
+            pk: Primary key of the record
+            field_name: Name of the field
+
+        Returns:
+            The old value, or None if not found
+        """
+        change = self._pk_to_change.get(pk)
+        return change.get_old_value(field_name) if change else None
+
+    def get_new_value(self, pk, field_name):
+        """
+        Get the new value for a specific record and field.
+
+        Args:
+            pk: Primary key of the record
+            field_name: Name of the field
+
+        Returns:
+            The new value, or None if not found
+        """
+        change = self._pk_to_change.get(pk)
+        return change.get_new_value(field_name) if change else None
+
+    def chunk(self, chunk_size):
+        """
+        Split ChangeSet into smaller chunks for memory-efficient processing.
+
+        Useful for processing very large bulk operations without loading
+        all data into memory at once.
+
+        Args:
+            chunk_size: Number of changes per chunk
+
+        Yields:
+            ChangeSet instances, each with up to chunk_size changes
+        """
+        for i in range(0, len(self.changes), chunk_size):
+            chunk_changes = self.changes[i : i + chunk_size]
+            yield ChangeSet(
+                self.model_cls,
+                chunk_changes,
+                self.operation_type,
+                self.operation_meta,
+            )

{django_bulk_hooks-0.2.61 → django_bulk_hooks-0.2.63}/django_bulk_hooks/conditions.py

@@ -40,7 +40,9 @@ def resolve_field_path(instance, field_path):
                     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,
+                            current_instance,
+                            field.attname,
+                            None,
                         )
                         continue
                 except:
@@ -203,7 +205,8 @@ class AndCondition(HookCondition):
 
     def check(self, instance, original_instance=None):
         return self.cond1.check(instance, original_instance) and self.cond2.check(
-            instance, original_instance,
+            instance,
+            original_instance,
         )
 
 
@@ -214,7 +217,8 @@ class OrCondition(HookCondition):
 
     def check(self, instance, original_instance=None):
         return self.cond1.check(instance, original_instance) or self.cond2.check(
-            instance, original_instance,
+            instance,
+            original_instance,
         )
 
 

{django_bulk_hooks-0.2.61 → django_bulk_hooks-0.2.63}/django_bulk_hooks/decorators.py

@@ -76,17 +76,11 @@ def select_related(*related_fields):
                 except (FieldDoesNotExist, AttributeError):
                     continue
 
-                if (
-                    relation_field.is_relation
-                    and not relation_field.many_to_many
-                    and not relation_field.one_to_many
-                ):
+                if relation_field.is_relation and not relation_field.many_to_many and not relation_field.one_to_many:
                     validated_fields.append(field)
                     direct_relation_fields[field] = relation_field
 
-            unsaved_related_ids_by_field = {
-                field: set() for field in direct_relation_fields
-            }
+            unsaved_related_ids_by_field = {field: set() for field in direct_relation_fields}
 
             saved_ids_to_fetch = []
             for obj in records:
@@ -94,10 +88,7 @@ def select_related(*related_fields):
                     needs_fetch = False
                     if hasattr(obj, "_state") and hasattr(obj._state, "fields_cache"):
                         try:
-                            needs_fetch = any(
-                                field not in obj._state.fields_cache
-                                for field in related_fields
-                            )
+                            needs_fetch = any(field not in obj._state.fields_cache for field in related_fields)
                         except (TypeError, AttributeError):
                             needs_fetch = True
                     else:
@@ -134,9 +125,7 @@ def select_related(*related_fields):
                     except Exception:
                         fetched_saved = {}
 
-            fetched_unsaved_by_field = {
-                field: {} for field in direct_relation_fields
-            }
+            fetched_unsaved_by_field = {field: {} for field in direct_relation_fields}
 
             for field_name, relation_field in direct_relation_fields.items():
                 related_ids = unsaved_related_ids_by_field[field_name]
@@ -282,6 +271,7 @@ def bulk_hook(model_cls, event, when=None, priority=None):
 
                 # Check function signature to determine which format to use
                 import inspect
+
                 sig = inspect.signature(func)
                 params = list(sig.parameters.keys())
 

{django_bulk_hooks-0.2.61 → django_bulk_hooks-0.2.63}/django_bulk_hooks/dispatcher.py

@@ -122,13 +122,15 @@ class HookDispatcher:
             condition: Optional condition to filter records
             changeset: ChangeSet with all record changes
         """
-        # Filter records based on condition
+        # NEW: Preload relationships needed for condition evaluation
         if condition:
-            filtered_changes = [
-                change
-                for change in changeset.changes
-                if condition.check(change.new_record, change.old_record)
-            ]
+            condition_relationships = self._extract_condition_relationships(condition, changeset.model_cls)
+            if condition_relationships:
+                self._preload_condition_relationships(changeset, condition_relationships)
+
+        # Filter records based on condition (now safe - relationships are preloaded)
+        if condition:
+            filtered_changes = [change for change in changeset.changes if condition.check(change.new_record, change.old_record)]
 
             if not filtered_changes:
                 # No records match condition, skip this hook
@@ -208,6 +210,94 @@ class HookDispatcher:
             )
             raise
 
+    def _extract_condition_relationships(self, condition, model_cls):
+        """
+        Extract relationship paths that a condition might access.
+
+        Args:
+            condition: HookCondition instance
+            model_cls: The model class
+
+        Returns:
+            set: Set of relationship field names to preload
+        """
+        relationships = set()
+
+        # Guard against Mock objects and non-condition objects
+        if not hasattr(condition, 'check') or hasattr(condition, '_mock_name'):
+            return relationships
+
+        # Handle different condition types
+        if hasattr(condition, 'field'):
+            # Extract relationships from field path (e.g., "status__value" -> "status")
+            field_path = condition.field
+            if isinstance(field_path, str):
+                if '__' in field_path:
+                    # Take the first part before __ (the relationship to preload)
+                    rel_field = field_path.split('__')[0]
+                    relationships.add(rel_field)
+                elif self._is_relationship_field(model_cls, field_path):
+                    relationships.add(field_path)
+
+        # Handle composite conditions (AndCondition, OrCondition)
+        if hasattr(condition, 'cond1') and hasattr(condition, 'cond2'):
+            relationships.update(self._extract_condition_relationships(condition.cond1, model_cls))
+            relationships.update(self._extract_condition_relationships(condition.cond2, model_cls))
+
+        # Handle NotCondition
+        if hasattr(condition, 'cond'):
+            relationships.update(self._extract_condition_relationships(condition.cond, model_cls))
+
+        return relationships
+
+    def _is_relationship_field(self, model_cls, field_name):
+        """Check if a field is a relationship field."""
+        try:
+            field = model_cls._meta.get_field(field_name)
+            return field.is_relation and not field.many_to_many
+        except:
+            return False
+
+    def _preload_condition_relationships(self, changeset, relationships):
+        """
+        Preload relationships needed for condition evaluation.
+
+        Args:
+            changeset: ChangeSet with records
+            relationships: Set of relationship field names to preload
+        """
+        if not relationships or not changeset.new_records:
+            return
+
+        # Use Django's select_related to preload relationships
+        relationship_list = list(relationships)
+
+        # Preload for new_records
+        if changeset.new_records:
+            # Use select_related on the queryset
+            ids = [obj.pk for obj in changeset.new_records if obj.pk is not None]
+            if ids:
+                preloaded = changeset.model_cls.objects.filter(pk__in=ids).select_related(*relationship_list).in_bulk()
+                # Update the objects in changeset with preloaded relationships
+                for obj in changeset.new_records:
+                    if obj.pk and obj.pk in preloaded:
+                        preloaded_obj = preloaded[obj.pk]
+                        for rel in relationship_list:
+                            if hasattr(preloaded_obj, rel):
+                                setattr(obj, rel, getattr(preloaded_obj, rel))
+
+        # Also handle unsaved objects by preloading their FK targets
+        for obj in changeset.new_records:
+            if obj.pk is None:  # Unsaved object
+                for rel in relationship_list:
+                    if hasattr(obj, f'{rel}_id'):
+                        rel_id = getattr(obj, f'{rel}_id')
+                        if rel_id:
+                            # Load the related object
+                            rel_model = getattr(changeset.model_cls._meta.get_field(rel).remote_field, 'model')
+                            rel_obj = rel_model.objects.get(pk=rel_id)
+                            setattr(obj, rel, rel_obj)
+
 
 # Global dispatcher instance
 _dispatcher: HookDispatcher | None = None
@@ -235,7 +325,7 @@ def get_dispatcher():
 def reset_dispatcher():
     """
     Reset the global dispatcher instance.
-    
+
     Useful for testing to ensure clean state between tests.
     """
     global _dispatcher

{django_bulk_hooks-0.2.61 → django_bulk_hooks-0.2.63}/django_bulk_hooks/handler.py

@@ -8,7 +8,8 @@ logger = logging.getLogger(__name__)
 class HookMeta(type):
     _registered = set()
     _class_hook_map: dict[
-        type, set[tuple],
+        type,
+        set[tuple],
     ] = {}  # Track which hooks belong to which class
 
     def __new__(mcs, name, bases, namespace):
@@ -103,4 +104,3 @@ class Hook(metaclass=HookMeta):
     All hook execution logic has been moved to HookDispatcher for
     a single, consistent execution path.
     """
-