django-bulk-hooks 0.1.254__tar.gz → 0.1.256__tar.gz

{django_bulk_hooks-0.1.254 → django_bulk_hooks-0.1.256}/PKG-INFO

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

{django_bulk_hooks-0.1.254 → django_bulk_hooks-0.1.256}/django_bulk_hooks/queryset.py

@@ -627,17 +627,24 @@ class HookQuerySetMixin:
                 # CRITICAL: Exclude auto_now fields from update_fields for existing records
                 # This prevents Django from including them in the ON CONFLICT DO UPDATE clause
                 if existing_records and update_fields:
+                    logger.debug(f"Processing {len(existing_records)} existing records with update_fields: {update_fields}")
+                    
                     # Identify auto_now fields that should be excluded from updates
                     auto_now_fields_to_exclude = set()
                     for field in model_cls._meta.local_fields:
                         if hasattr(field, "auto_now") and field.auto_now:
                             auto_now_fields_to_exclude.add(field.name)
                     
+                    logger.debug(f"Found auto_now fields: {auto_now_fields_to_exclude}")
+                    
                     # Filter out auto_now fields from update_fields for existing records
                     if auto_now_fields_to_exclude:
                         # Create a filtered version of update_fields that excludes auto_now fields
                         filtered_update_fields = [f for f in update_fields if f not in auto_now_fields_to_exclude]
                         
+                        logger.debug(f"Filtered update_fields: {filtered_update_fields}")
+                        logger.debug(f"Excluded auto_now fields: {auto_now_fields_to_exclude}")
+                        
                         # Store the original update_fields to restore later
                         ctx.original_update_fields = update_fields
                         ctx.auto_now_fields_excluded = auto_now_fields_to_exclude
@@ -645,6 +652,12 @@ class HookQuerySetMixin:
                         # Use the filtered update_fields for the database operation
                         # This prevents Django from overwriting the timestamps during upsert
                         update_fields = filtered_update_fields
+                        
+                        logger.debug(f"Final update_fields for DB operation: {update_fields}")
+                    else:
+                        logger.debug("No auto_now fields found to exclude")
+                else:
+                    logger.debug(f"No existing records or update_fields to process. existing_records: {len(existing_records) if existing_records else 0}, update_fields: {update_fields}")
                 
                 # Run validation hooks on all records
                 if not bypass_validation:
@@ -694,6 +707,10 @@ class HookQuerySetMixin:
             # but we need to call it on the base manager to avoid recursion
             # Filter out custom parameters that Django's bulk_create doesn't accept
 
+            logger.debug(f"Calling Django bulk_create with update_fields: {update_fields}")
+            logger.debug(f"Calling Django bulk_create with update_conflicts: {update_conflicts}")
+            logger.debug(f"Calling Django bulk_create with unique_fields: {unique_fields}")
+            
             result = super().bulk_create(
                 objs,
                 batch_size=batch_size,
@@ -702,15 +719,19 @@ class HookQuerySetMixin:
                 update_fields=update_fields,
                 unique_fields=unique_fields,
             )
+            
+            logger.debug(f"Django bulk_create completed with result: {result}")
 
         # Fire AFTER hooks
         if not bypass_hooks:
             if update_conflicts and unique_fields:
                 # Restore original update_fields if we modified them
                 if hasattr(ctx, 'original_update_fields'):
+                    logger.debug(f"Restoring original update_fields: {ctx.original_update_fields}")
                     update_fields = ctx.original_update_fields
                     delattr(ctx, 'original_update_fields')
                     delattr(ctx, 'auto_now_fields_excluded')
+                    logger.debug(f"Restored update_fields: {update_fields}")
                 
                 # For upsert operations, we need to determine which records were actually created vs updated
                 # Use the same logic as before to separate records
@@ -794,7 +815,7 @@ class HookQuerySetMixin:
             )
 
         logger.debug(
-            f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}"
+            f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)} fields={fields}"
         )
 
         # Check for MTI
@@ -818,15 +839,35 @@ class HookQuerySetMixin:
         # Handle auto_now fields like Django's update_or_create does
         fields_set = set(fields)
         pk_fields = model_cls._meta.pk_fields
+        auto_now_fields = []
+        logger.debug(f"Checking for auto_now fields in {model_cls.__name__}")
         for field in model_cls._meta.local_concrete_fields:
             # Only add auto_now fields (like updated_at) that aren't already in the fields list
             # Don't include auto_now_add fields (like created_at) as they should only be set on creation
             if hasattr(field, "auto_now") and field.auto_now:
+                logger.debug(f"Found auto_now field: {field.name}")
                 if field.name not in fields_set and field.name not in pk_fields:
                     fields_set.add(field.name)
                     if field.name != field.attname:
                         fields_set.add(field.attname)
+                    auto_now_fields.append(field.name)
+                    logger.debug(f"Added auto_now field {field.name} to fields list")
+                else:
+                    logger.debug(f"Auto_now field {field.name} already in fields list or is PK")
+            elif hasattr(field, "auto_now_add") and field.auto_now_add:
+                logger.debug(f"Found auto_now_add field: {field.name} (skipping)")
+        
+        logger.debug(f"Auto_now fields detected: {auto_now_fields}")
         fields = list(fields_set)
+        
+        # Set auto_now field values to current timestamp
+        if auto_now_fields:
+            from django.utils import timezone
+            current_time = timezone.now()
+            logger.debug(f"Setting auto_now fields {auto_now_fields} to current time: {current_time}")
+            for obj in objs:
+                for field_name in auto_now_fields:
+                    setattr(obj, field_name, current_time)
 
         # Handle MTI models differently
         if is_mti:
@@ -839,17 +880,20 @@ class HookQuerySetMixin:
                 if k not in ["bypass_hooks", "bypass_validation"]
             }
             logger.debug("Calling Django bulk_update")
-            # Build a per-object concrete value map to avoid leaking expressions into hooks
-            value_map = {}
-            for obj in objs:
-                if obj.pk is None:
-                    continue
-                field_values = {}
-                for field_name in fields:
-                    # Capture raw values assigned on the object (not expressions)
-                    field_values[field_name] = getattr(obj, field_name)
-                if field_values:
-                    value_map[obj.pk] = field_values
+                    # Build a per-object concrete value map to avoid leaking expressions into hooks
+        value_map = {}
+        logger.debug(f"Building value map for {len(objs)} objects with fields: {fields}")
+        for obj in objs:
+            if obj.pk is None:
+                continue
+            field_values = {}
+            for field_name in fields:
+                # Capture raw values assigned on the object (not expressions)
+                field_values[field_name] = getattr(obj, field_name)
+                if field_name in auto_now_fields:
+                    logger.debug(f"Object {obj.pk} {field_name}: {field_values[field_name]}")
+            if field_values:
+                value_map[obj.pk] = field_values
 
             # Make the value map available to the subsequent update() call
             if value_map:

{django_bulk_hooks-0.1.254 → django_bulk_hooks-0.1.256}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.254"
+version = "0.1.256"
 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"