django-bulk-hooks 0.2.9__tar.gz → 0.2.11__tar.gz

{django_bulk_hooks-0.2.9 → django_bulk_hooks-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.9
+Version: 0.2.11
 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 → django_bulk_hooks-0.2.11}/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-0.2.9 → django_bulk_hooks-0.2.11}/django_bulk_hooks/dispatcher.py

@@ -108,7 +108,9 @@ class HookDispatcher:
             return
 
         # Execute hooks in priority order
+        logger.info(f"🔥 HOOKS: Executing {len(hooks)} hooks for {changeset.model_cls.__name__}.{event}")
         for handler_cls, method_name, condition, priority in hooks:
+            logger.info(f"  → {handler_cls.__name__}.{method_name} (priority={priority})")
             self._execute_hook(handler_cls, method_name, condition, changeset)
 
     def _execute_hook(self, handler_cls, method_name, condition, changeset):
@@ -159,6 +161,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 +171,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 +183,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(
@@ -197,12 +206,14 @@ class HookDispatcher:
         # New hooks that do use changeset:    def hook(self, changeset, new_records, old_records, **kwargs)
         # 
         # This is standard Python framework design (see Django signals, Flask hooks, etc.)
+        logger.info(f"    🚀 Executing: {handler_cls.__name__}.{method_name}")
         try:
             method(
                 changeset=filtered_changeset,
                 new_records=filtered_changeset.new_records,
                 old_records=filtered_changeset.old_records,
             )
+            logger.info(f"    ✅ Completed: {handler_cls.__name__}.{method_name}")
         except Exception as e:
             # Fail-fast: re-raise to rollback transaction
             logger.error(

{django_bulk_hooks-0.2.9 → django_bulk_hooks-0.2.11}/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-0.2.9 → django_bulk_hooks-0.2.11}/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 → django_bulk_hooks-0.2.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.2.9"
+version = "0.2.11"
 description = "Hook-style hooks for Django bulk operations like bulk_create and bulk_update."
 authors = ["Konrad Beck <konrad.beck@merchantcapital.co.za>"]
 readme = "README.md"

django_bulk_hooks-0.2.9/django_bulk_hooks/debug_utils.py

@@ -1,145 +0,0 @@
-"""
-Debug utilities for tracking N+1 queries and database performance.
-"""
-
-import logging
-import time
-from functools import wraps
-from django.db import connection
-from django.conf import settings
-
-logger = logging.getLogger(__name__)
-
-
-def track_queries(func):
-    """
-    Decorator to track database queries during function execution.
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        # Reset query count
-        initial_queries = len(connection.queries)
-        initial_time = time.time()
-
-        logger.debug(
-            f"QUERY DEBUG: Starting {func.__name__} - initial query count: {initial_queries}"
-        )
-
-        try:
-            result = func(*args, **kwargs)
-
-            final_queries = len(connection.queries)
-            final_time = time.time()
-            query_count = final_queries - initial_queries
-            duration = final_time - initial_time
-
-            logger.debug(
-                f"QUERY DEBUG: Completed {func.__name__} - queries executed: {query_count}, duration: {duration:.4f}s"
-            )
-
-            # Log all queries executed during this function
-            if query_count > 0:
-                logger.debug(f"QUERY DEBUG: Queries executed in {func.__name__}:")
-                for i, query in enumerate(connection.queries[initial_queries:], 1):
-                    logger.debug(
-                        f"QUERY DEBUG:   {i}. {query['sql'][:100]}... (time: {query['time']})"
-                    )
-
-            return result
-
-        except Exception as e:
-            final_queries = len(connection.queries)
-            query_count = final_queries - initial_queries
-            logger.debug(
-                f"QUERY DEBUG: Exception in {func.__name__} - queries executed: {query_count}"
-            )
-            raise
-
-    return wrapper
-
-
-def log_query_count(context=""):
-    """
-    Log the current query count with optional context.
-    """
-    query_count = len(connection.queries)
-    logger.debug(f"QUERY DEBUG: Query count at {context}: {query_count}")
-
-
-def log_recent_queries(count=5, context=""):
-    """
-    Log the most recent database queries.
-    """
-    recent_queries = connection.queries[-count:] if connection.queries else []
-    logger.debug(f"QUERY DEBUG: Recent {len(recent_queries)} queries at {context}:")
-    for i, query in enumerate(recent_queries, 1):
-        logger.debug(
-            f"QUERY DEBUG:   {i}. {query['sql'][:100]}... (time: {query['time']})"
-        )
-
-
-class QueryTracker:
-    """
-    Context manager for tracking database queries.
-    """
-
-    def __init__(self, context_name="QueryTracker"):
-        self.context_name = context_name
-        self.initial_queries = 0
-        self.start_time = 0
-
-    def __enter__(self):
-        self.initial_queries = len(connection.queries)
-        self.start_time = time.time()
-        logger.debug(
-            f"QUERY DEBUG: Starting {self.context_name} - initial query count: {self.initial_queries}"
-        )
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        final_queries = len(connection.queries)
-        final_time = time.time()
-        query_count = final_queries - self.initial_queries
-        duration = final_time - self.start_time
-
-        logger.debug(
-            f"QUERY DEBUG: Completed {self.context_name} - queries executed: {query_count}, duration: {duration:.4f}s"
-        )
-
-        if query_count > 0:
-            logger.debug(f"QUERY DEBUG: Queries executed in {self.context_name}:")
-            for i, query in enumerate(connection.queries[self.initial_queries :], 1):
-                logger.debug(
-                    f"QUERY DEBUG:   {i}. {query['sql'][:100]}... (time: {query['time']})"
-                )
-
-        return False  # Don't suppress exceptions
-
-
-def enable_django_query_logging():
-    """
-    Enable Django's built-in query logging.
-    """
-    if not settings.DEBUG:
-        logger.warning("Django query logging can only be enabled in DEBUG mode")
-        return
-
-    # Enable query logging
-    settings.LOGGING = {
-        "version": 1,
-        "disable_existing_loggers": False,
-        "handlers": {
-            "console": {
-                "class": "logging.StreamHandler",
-            },
-        },
-        "loggers": {
-            "django.db.backends": {
-                "level": "DEBUG",
-                "handlers": ["console"],
-            },
-        },
-    }
-
-    logger.info("Django query logging enabled")