django-bulk-hooks 0.1.57__tar.gz → 0.1.60__tar.gz

{django_bulk_hooks-0.1.57 → django_bulk_hooks-0.1.60}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.57
+Version: 0.1.60
 Summary: Lifecycle-style hooks for Django bulk operations like bulk_create and bulk_update.
-Home-page: https://github.com/AugendLimited/django-bulk-hooks
 License: MIT
 Keywords: django,bulk,hooks
 Author: Konrad Beck
@@ -14,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Django (>=4.0)
+Project-URL: Homepage, https://github.com/AugendLimited/django-bulk-hooks
 Project-URL: Repository, https://github.com/AugendLimited/django-bulk-hooks
 Description-Content-Type: text/markdown
 

{django_bulk_hooks-0.1.57 → django_bulk_hooks-0.1.60}/django_bulk_hooks/context.py

@@ -1,16 +1,16 @@
-import threading
-from collections import deque
-
-_hook_context = threading.local()
-
-
-def get_hook_queue():
-    if not hasattr(_hook_context, "queue"):
-        _hook_context.queue = deque()
-    return _hook_context.queue
-
-
-class TriggerContext:
-    def __init__(self, model_cls, metadata=None):
-        self.model_cls = model_cls
-        self.metadata = metadata or {}
+import threading
+from collections import deque
+
+_hook_context = threading.local()
+
+
+def get_hook_queue():
+    if not hasattr(_hook_context, "queue"):
+        _hook_context.queue = deque()
+    return _hook_context.queue
+
+
+class TriggerContext:
+    def __init__(self, model_cls, metadata=None):
+        self.model_cls = model_cls
+        self.metadata = metadata or {}

{django_bulk_hooks-0.1.57 → django_bulk_hooks-0.1.60}/django_bulk_hooks/decorators.py

@@ -3,6 +3,8 @@ from functools import wraps
 
 from django.core.exceptions import FieldDoesNotExist
 from django_bulk_hooks.enums import DEFAULT_PRIORITY
+from django_bulk_hooks.constants import BEFORE_UPDATE
+from django_bulk_hooks.handler import TriggerHandler
 
 
 def hook(event, *, model, condition=None, priority=DEFAULT_PRIORITY):
@@ -52,19 +54,29 @@ def select_related(*related_fields):
             if not new_records:
                 return func(*args, **kwargs)
 
-            # In-place preload
+            # Determine which instances actually need preloading
             model_cls = new_records[0].__class__
-            ids = [obj.pk for obj in new_records if obj.pk is not None]
-            if not ids:
-                return func(*args, **kwargs)
+            ids_to_fetch = []
+            for obj in new_records:
+                if obj.pk is None:
+                    continue
+                # if any related field is not already cached on the instance,
+                # mark it for fetching
+                if any(field not in obj._state.fields_cache for field in related_fields):
+                    ids_to_fetch.append(obj.pk)
 
-            fetched = model_cls.objects.select_related(*related_fields).in_bulk(ids)
+            fetched = {}
+            if ids_to_fetch:
+                fetched = model_cls.objects.select_related(*related_fields).in_bulk(ids_to_fetch)
 
             for obj in new_records:
                 preloaded = fetched.get(obj.pk)
                 if not preloaded:
                     continue
                 for field in related_fields:
+                    if field in obj._state.fields_cache:
+                        # don't override values that were explicitly set or already loaded
+                        continue
                     if "." in field:
                         raise ValueError(
                             f"@preload_related does not support nested fields like '{field}'"
@@ -91,3 +103,20 @@ def select_related(*related_fields):
         return wrapper
 
     return decorator
+
+
+def bulk_hook(model_cls, event, when=None, priority=None):
+    """
+    Decorator to register a bulk hook for a model.
+    
+    Args:
+        model_cls: The model class to hook into
+        event: The event to hook into (e.g., BEFORE_UPDATE, AFTER_UPDATE)
+        when: Optional condition for when the hook should run
+        priority: Optional priority for hook execution order
+    """
+    def decorator(func):
+        # Register the hook
+        TriggerHandler.register_hook(model_cls, event, func, when, priority)
+        return func
+    return decorator

{django_bulk_hooks-0.1.57 → django_bulk_hooks-0.1.60}/django_bulk_hooks/manager.py

@@ -10,6 +10,9 @@ from django_bulk_hooks.constants import (
 )
 from django_bulk_hooks.context import TriggerContext
 from django_bulk_hooks.queryset import LifecycleQuerySet
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class BulkLifecycleManager(models.Manager):
@@ -34,6 +37,18 @@ class BulkLifecycleManager(models.Manager):
             originals = list(model_cls.objects.filter(pk__in=[obj.pk for obj in objs]))
             ctx = TriggerContext(model_cls)
             engine.run(model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx)
+            
+            # Automatically detect fields that were modified during BEFORE_UPDATE hooks
+            modified_fields = self._detect_modified_fields(objs, originals)
+            if modified_fields:
+                # Convert to set for efficient union operation
+                fields_set = set(fields)
+                fields_set.update(modified_fields)
+                fields = list(fields_set)
+                logger.info(
+                    "Automatically including modified fields in bulk_update: %s",
+                    modified_fields
+                )
 
         for i in range(0, len(objs), self.CHUNK_SIZE):
             chunk = objs[i : i + self.CHUNK_SIZE]
@@ -47,6 +62,49 @@ class BulkLifecycleManager(models.Manager):
 
         return objs
 
+    def _detect_modified_fields(self, new_instances, original_instances):
+        """
+        Detect fields that were modified during BEFORE_UPDATE hooks by comparing
+        new instances with their original values.
+        """
+        if not original_instances:
+            return set()
+        
+        # Create a mapping of pk to original instance for efficient lookup
+        original_map = {obj.pk: obj for obj in original_instances if obj.pk is not None}
+        
+        modified_fields = set()
+        
+        for new_instance in new_instances:
+            if new_instance.pk is None:
+                continue
+                
+            original = original_map.get(new_instance.pk)
+            if not original:
+                continue
+            
+            # Compare all fields to detect changes
+            for field in new_instance._meta.fields:
+                if field.name == 'id':
+                    continue
+                    
+                new_value = getattr(new_instance, field.name)
+                original_value = getattr(original, field.name)
+                
+                # Handle different field types appropriately
+                if field.is_relation:
+                    # For foreign keys, compare the pk values
+                    new_pk = new_value.pk if new_value else None
+                    original_pk = original_value.pk if original_value else None
+                    if new_pk != original_pk:
+                        modified_fields.add(field.name)
+                else:
+                    # For regular fields, use direct comparison
+                    if new_value != original_value:
+                        modified_fields.add(field.name)
+        
+        return modified_fields
+
     @transaction.atomic
     def bulk_create(
         self, objs, batch_size=None, ignore_conflicts=False, bypass_hooks=False

{django_bulk_hooks-0.1.57 → django_bulk_hooks-0.1.60}/django_bulk_hooks/queryset.py

@@ -28,16 +28,17 @@ class LifecycleQuerySet(models.QuerySet):
                 setattr(obj, field, value)
 
         # Run BEFORE_UPDATE hooks
-        from django_bulk_hooks.context import TriggerContext
         from django_bulk_hooks import engine
+        from django_bulk_hooks.context import TriggerContext
+
         ctx = TriggerContext(model_cls)
         engine.run(model_cls, "before_update", instances, originals, ctx=ctx)
 
-        # Use Django's built-in update logic directly through the base queryset
-        update_count = super(models.QuerySet, self).update(**kwargs)
+        # Use Django's built-in update logic directly
+        queryset = self.model._base_manager.filter(pk__in=pks)
+        update_count = queryset.update(**kwargs)
 
         # Run AFTER_UPDATE hooks
         engine.run(model_cls, "after_update", instances, originals, ctx=ctx)
 
         return update_count
-

{django_bulk_hooks-0.1.57 → django_bulk_hooks-0.1.60}/pyproject.toml

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