django-bulk-hooks 0.2.9__py3-none-any.whl → 0.2.10__py3-none-any.whl

django_bulk_hooks/decorators.py

@@ -1,4 +1,5 @@
 import inspect
+import logging
 from functools import wraps
 
 from django.core.exceptions import FieldDoesNotExist
@@ -6,6 +7,8 @@ from django.core.exceptions import FieldDoesNotExist
 from django_bulk_hooks.enums import DEFAULT_PRIORITY
 from django_bulk_hooks.registry import register_hook
 
+logger = logging.getLogger(__name__)
+
 
 def hook(event, *, model, condition=None, priority=DEFAULT_PRIORITY):
     """
@@ -35,7 +38,7 @@ def select_related(*related_fields):
     def decorator(func):
         sig = inspect.signature(func)
 
-        def preload_related(records, *, model_cls=None):
+        def preload_related(records, *, model_cls=None, skip_fields=None):
             if not isinstance(records, list):
                 raise TypeError(
                     f"@select_related expects a list of model instances, got {type(records)}"
@@ -47,6 +50,9 @@ def select_related(*related_fields):
             if model_cls is None:
                 model_cls = records[0].__class__
 
+            if skip_fields is None:
+                skip_fields = set()
+
             # Validate field notation upfront
             for field in related_fields:
                 if "." in field:
@@ -161,6 +167,10 @@ def select_related(*related_fields):
                         continue
 
                     for field in related_fields:
+                        # Skip preloading if this relationship conflicts with FK field being updated
+                        if field in skip_fields:
+                            continue
+
                         if fields_cache is not None and field in fields_cache:
                             continue
 
@@ -179,6 +189,10 @@ def select_related(*related_fields):
                     continue
 
                 for field_name, relation_field in direct_relation_fields.items():
+                    # Skip preloading if this relationship conflicts with FK field being updated
+                    if field_name in skip_fields:
+                        continue
+
                     if fields_cache is not None and field_name in fields_cache:
                         continue
 
@@ -198,6 +212,12 @@ def select_related(*related_fields):
                     if fields_cache is not None:
                         fields_cache[field_name] = rel_obj
 
+        def preload_with_skip_fields(records, *, model_cls=None, skip_fields=None):
+            """Wrapper that applies skip_fields logic to the preload function"""
+            if skip_fields is None:
+                skip_fields = set()
+            return preload_related(records, model_cls=model_cls, skip_fields=skip_fields)
+
         @wraps(func)
         def wrapper(*args, **kwargs):
             bound = sig.bind_partial(*args, **kwargs)
@@ -210,13 +230,27 @@ def select_related(*related_fields):
 
             new_records = bound.arguments["new_records"]
 
-            model_cls_override = bound.arguments.get("model_cls")
+            if not isinstance(new_records, list):
+                raise TypeError(
+                    f"@select_related expects a list of model instances, got {type(new_records)}"
+                )
+
+            if not new_records:
+                # Empty list, nothing to preload
+                return func(*args, **kwargs)
 
-            preload_related(new_records, model_cls=model_cls_override)
+            # Validate field notation upfront (same as in preload_related)
+            for field in related_fields:
+                if "." in field:
+                    raise ValueError(
+                        f"Invalid field notation '{field}'. Use Django ORM __ notation (e.g., 'parent__field')"
+                    )
 
-            return func(*bound.args, **bound.kwargs)
+            # Don't preload here - let the dispatcher handle it
+            # The dispatcher will call the preload function with skip_fields
+            return func(*args, **kwargs)
 
-        wrapper._select_related_preload = preload_related
+        wrapper._select_related_preload = preload_with_skip_fields
         wrapper._select_related_fields = related_fields
 
         return wrapper
@@ -241,8 +275,22 @@ def bulk_hook(model_cls, event, when=None, priority=None):
             def __init__(self):
                 self.func = func
 
-            def handle(self, new_records=None, old_records=None, **kwargs):
-                return self.func(new_records, old_records, **kwargs)
+            def handle(self, changeset=None, new_records=None, old_records=None, **kwargs):
+                # Support both old and new hook signatures for backward compatibility
+                # Old signature: def hook(self, new_records, old_records, **kwargs)
+                # New signature: def hook(self, changeset, new_records, old_records, **kwargs)
+
+                # Check function signature to determine which format to use
+                import inspect
+                sig = inspect.signature(func)
+                params = list(sig.parameters.keys())
+
+                if 'changeset' in params:
+                    # New signature with changeset
+                    return self.func(changeset, new_records, old_records, **kwargs)
+                else:
+                    # Old signature without changeset
+                    return self.func(new_records, old_records, **kwargs)
 
         # Register the hook using the registry
         register_hook(

django_bulk_hooks/dispatcher.py

@@ -159,6 +159,9 @@ class HookDispatcher:
             try:
                 model_cls_override = getattr(handler, "model_cls", None)
 
+                # Get FK fields being updated to avoid preloading conflicting relationships
+                skip_fields = changeset.operation_meta.get('fk_fields_being_updated', set())
+
                 # Preload for new_records
                 if filtered_changeset.new_records:
                     logger.debug(
@@ -166,7 +169,9 @@ class HookDispatcher:
                         f"new_records for {handler_cls.__name__}.{method_name}"
                     )
                     preload_func(
-                        filtered_changeset.new_records, model_cls=model_cls_override
+                        filtered_changeset.new_records,
+                        model_cls=model_cls_override,
+                        skip_fields=skip_fields
                     )
 
                 # Also preload for old_records (for conditions that check previous values)
@@ -176,7 +181,9 @@ class HookDispatcher:
                         f"old_records for {handler_cls.__name__}.{method_name}"
                     )
                     preload_func(
-                        filtered_changeset.old_records, model_cls=model_cls_override
+                        filtered_changeset.old_records,
+                        model_cls=model_cls_override,
+                        skip_fields=skip_fields
                     )
             except Exception:
                 logger.debug(

django_bulk_hooks/operations/analyzer.py

@@ -257,10 +257,6 @@ class ModelAnalyzer:
         F() expressions, Subquery, Case, etc.) into concrete values and applies
         them to the instances.
         
-        CRITICAL: When setting FK fields by their attname (e.g., business_id),
-        we must manually clear the relationship cache (e.g., business) to match
-        Django's ForeignKey descriptor behavior.
-        
         Args:
             instances: List of model instances to update
             update_kwargs: Dict of {field_name: value_or_expression}
@@ -274,66 +270,8 @@ class ModelAnalyzer:
         fields_updated = list(update_kwargs.keys())
         
         for field_name, value in update_kwargs.items():
-            # Determine if this is a FK field being set by its attname
-            field_info = self._get_fk_field_info(field_name)
-            
             for instance in instances:
                 resolved_value = self.resolve_expression(field_name, value, instance)
                 setattr(instance, field_name, resolved_value)
-                
-                # Clear relationship cache when FK field is set directly
-                # This replicates Django's ForeignKey descriptor behavior
-                if field_info and field_info['is_fk_attname']:
-                    self._clear_fk_cache(instance, field_info['accessor_name'])
-        
-        return fields_updated
-
-    def _get_fk_field_info(self, field_name):
-        """
-        Get information about a FK field if field_name is a FK attname.
-        
-        Args:
-            field_name: Field name to check
-            
-        Returns:
-            Dict with FK info or None if not a FK field
-        """
-        try:
-            # Check all fields to find if this is a FK attname
-            for field in self.model_cls._meta.get_fields():
-                if (field.is_relation and 
-                    not field.many_to_many and 
-                    not field.one_to_many and
-                    hasattr(field, 'attname') and 
-                    field.attname == field_name):
-                    # This is a FK field being set by its attname (e.g., business_id)
-                    return {
-                        'is_fk_attname': True,
-                        'accessor_name': field.name,  # e.g., 'business'
-                        'field': field
-                    }
-        except Exception as e:
-            logger.debug(f"Error checking FK field info for {field_name}: {e}")
-        
-        return None
-
-    def _clear_fk_cache(self, instance, accessor_name):
-        """
-        Clear cached relationship when FK field is set directly.
         
-        This replicates what Django's ForeignKey descriptor __set__ does:
-        when you set a FK field, Django clears the cached related object.
-        
-        Args:
-            instance: Model instance
-            accessor_name: Name of the relationship accessor (e.g., 'business')
-        """
-        try:
-            if hasattr(instance, '_state') and hasattr(instance._state, 'fields_cache'):
-                instance._state.fields_cache.pop(accessor_name, None)
-                logger.debug(
-                    f"Cleared FK cache for '{accessor_name}' on {self.model_cls.__name__}"
-                )
-        except Exception as e:
-            # Don't fail the operation, just log
-            logger.debug(f"Could not clear FK cache for {accessor_name}: {e}")
+        return fields_updated

django_bulk_hooks/operations/coordinator.py

@@ -276,6 +276,9 @@ class BulkOperationCoordinator:
         # Fetch old records for comparison (single bulk query)
         old_records_map = self.analyzer.fetch_old_records_map(instances)
 
+        # Detect FK fields being updated to prevent @select_related conflicts
+        fk_fields_being_updated = self._get_fk_fields_being_updated(update_kwargs)
+
         # Build changeset for VALIDATE and BEFORE hooks
         # instances now have the "intended" values from update_kwargs
         changeset = build_changeset_for_update(
@@ -285,6 +288,10 @@ class BulkOperationCoordinator:
             old_records_map=old_records_map,
         )
 
+        # Add FK field info to changeset meta for dispatcher to use
+        if fk_fields_being_updated:
+            changeset.operation_meta['fk_fields_being_updated'] = fk_fields_being_updated
+
         # Execute VALIDATE and BEFORE hooks
         # Hooks can now modify the instances and changes will persist
         if not bypass_validation:
@@ -470,3 +477,35 @@ class BulkOperationCoordinator:
             self.dispatcher.dispatch(model_changeset, f"after_{event_prefix}", bypass_hooks=False)
 
         return result
+
+    def _get_fk_fields_being_updated(self, update_kwargs):
+        """
+        Get the relationship names for FK fields being updated.
+
+        This helps @select_related avoid preloading relationships that are
+        being modified, which can cause cache conflicts.
+
+        Args:
+            update_kwargs: Dict of fields being updated
+
+        Returns:
+            Set of relationship names (e.g., {'business'}) for FK fields being updated
+        """
+        fk_relationships = set()
+
+        for field_name in update_kwargs.keys():
+            try:
+                field = self.model_cls._meta.get_field(field_name)
+                if (field.is_relation and
+                    not field.many_to_many and
+                    not field.one_to_many and
+                    hasattr(field, 'attname') and
+                    field.attname == field_name):
+                    # This is a FK field being updated by its attname (e.g., business_id)
+                    # Add the relationship name (e.g., 'business') to skip list
+                    fk_relationships.add(field.name)
+            except Exception:
+                # If field lookup fails, skip it
+                continue
+
+        return fk_relationships

{django_bulk_hooks-0.2.9.dist-info → django_bulk_hooks-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.9
+Version: 0.2.10
 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.9.dist-info → django_bulk_hooks-0.2.10.dist-info}/RECORD

@@ -4,8 +4,8 @@ django_bulk_hooks/conditions.py,sha256=qtGjToKXC8FPUPK31Mib-GMzc9GSdrH90M2pT3CIs
 django_bulk_hooks/constants.py,sha256=PxpEETaO6gdENcTPoXS586lerGKVP3nmjpDvOkmhYxI,509
 django_bulk_hooks/context.py,sha256=mqaC5-yESDTA5ruI7fuXlt8qSgKuOFp0mjq7h1-4HdQ,1926
 django_bulk_hooks/debug_utils.py,sha256=6T32E_Pms6gbCl94A55fJAe_ynFsK_CJBTaPcsG8tik,4578
-django_bulk_hooks/decorators.py,sha256=B1mzXjVx9XWB8kwvJ97ZvBsgnVcpvtQWBpDHytVRtYo,9611
-django_bulk_hooks/dispatcher.py,sha256=L5_hSqENuKXDftJOdMetfjdZkiakUgkheqU8HpWKaOI,8214
+django_bulk_hooks/decorators.py,sha256=hc8MSG5XXEiT5kgsf4Opzpj8jAb-OYqcvssuZxCIncQ,11894
+django_bulk_hooks/dispatcher.py,sha256=RSicSwwoO5_AjxPB1co4l9LJEWNUEaSqzILDS7v-SIc,8553
 django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
 django_bulk_hooks/factory.py,sha256=JmjQiJPfAnytXrO6r6qOadX5yX0-sfpbZ9V8nwX3MAg,20013
 django_bulk_hooks/handler.py,sha256=2-k0GPWGSQ6acfvV0qJgDH8aa0z51DqdpX5vSJ6Uawk,4759
@@ -13,14 +13,14 @@ django_bulk_hooks/helpers.py,sha256=Yopvl588VbKOi2kHEsQcEcI5jw5jiNA2MuF6Ce1VP0c,
 django_bulk_hooks/manager.py,sha256=3mFzB0ZzHHeXWdKGObZD_H0NlskHJc8uYBF69KKdAXU,4068
 django_bulk_hooks/models.py,sha256=62tn5wL55EjJVOsZofMluhEJB8bH7CzBvH0vd214_RY,2570
 django_bulk_hooks/operations/__init__.py,sha256=5L5NnwiFw8Yn5WO6-38eGdCYBkA0URpwyDcAdeYfc5w,550
-django_bulk_hooks/operations/analyzer.py,sha256=wmlO5RnITmo7JPFHpERObpAts_5TfHWMjwP1RQss7lM,11753
+django_bulk_hooks/operations/analyzer.py,sha256=s6FM53ho1raPdKU-VjjW0SWymXyrJe0I_Wu8XsXFdSY,9065
 django_bulk_hooks/operations/bulk_executor.py,sha256=7VJgeTFcMQ9ZELvCV6WR6udUPJNL6Kf-w9iEva6pIPA,18271
-django_bulk_hooks/operations/coordinator.py,sha256=XH84Vl8pLVOWXzpUuTNf6bX6Zm0__no02TFfr6DW6Jg,16599
+django_bulk_hooks/operations/coordinator.py,sha256=tCQA0yfnt1bh8hLR_g_WlZc2tRpnWDbTb9aWKaAfWmo,18174
 django_bulk_hooks/operations/mti_handler.py,sha256=eIH-tImMqcWR5lLQr6Ca-HeVYta-UkXk5X5fcpS885Y,18245
 django_bulk_hooks/operations/mti_plans.py,sha256=fHUYbrUAHq8UXqxgAD43oHdTxOnEkmpxoOD4Qrzfqk8,2878
 django_bulk_hooks/queryset.py,sha256=ody4MXrRREL27Ts2ey1UpS0tb5Dxnw-6kN3unxPQ3zY,5860
 django_bulk_hooks/registry.py,sha256=UPerNhtVz_9tKZqrYSZD2LhjAcs4F6hVUuk8L5oOeHc,8821
-django_bulk_hooks-0.2.9.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.2.9.dist-info/METADATA,sha256=zklF13vbEibe1zzHXzNDrQVFGXorKSbJmpAZcLmL4Pw,9264
-django_bulk_hooks-0.2.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.2.9.dist-info/RECORD,,
+django_bulk_hooks-0.2.10.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.2.10.dist-info/METADATA,sha256=P8Z9_k29syzVElm5ZOBVv4M4dF3l_Hw0jgg7Otm0IKM,9265
+django_bulk_hooks-0.2.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.2.10.dist-info/RECORD,,