django-bulk-hooks 0.1.260__tar.gz → 0.1.262__tar.gz

{django_bulk_hooks-0.1.260 → django_bulk_hooks-0.1.262}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.260
+Version: 0.1.262
 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.260 → django_bulk_hooks-0.1.262}/django_bulk_hooks/queryset.py

@@ -648,38 +648,38 @@ class HookQuerySetMixin:
                 
                 # Remove duplicate code since we're now handling this above
                 
-                # CRITICAL: Exclude auto_now fields from update_fields for existing records
-                # This prevents Django from including them in the ON CONFLICT DO UPDATE clause
+                # CRITICAL: Handle auto_now fields intelligently for existing records
+                # We need to exclude them from Django's ON CONFLICT DO UPDATE clause to prevent
+                # Django's default behavior, but still ensure they get updated via pre_save
                 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()
+
+                    # Identify auto_now fields
+                    auto_now_fields = 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
+                            auto_now_fields.add(field.name)
+
+                    logger.debug(f"Found auto_now fields: {auto_now_fields}")
+
+                    if auto_now_fields:
+                        # Store original update_fields and auto_now fields for later restoration
                         ctx.original_update_fields = update_fields
-                        ctx.auto_now_fields_excluded = auto_now_fields_to_exclude
-                        
-                        # Use the filtered update_fields for the database operation
-                        # This prevents Django from overwriting the timestamps during upsert
+                        ctx.auto_now_fields = auto_now_fields
+
+                        # Filter out auto_now fields from update_fields for the database operation
+                        # This prevents Django from including them in ON CONFLICT DO UPDATE
+                        filtered_update_fields = [f for f in update_fields if f not in auto_now_fields]
+
+                        logger.debug(f"Filtered update_fields: {filtered_update_fields}")
+                        logger.debug(f"Excluded auto_now fields: {auto_now_fields}")
+
+                        # Use filtered update_fields for Django's bulk_create operation
                         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")
+                        logger.debug("No auto_now fields found to handle")
                 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}")
                 
@@ -749,14 +749,32 @@ class HookQuerySetMixin:
         # Fire AFTER hooks
         if not bypass_hooks:
             if update_conflicts and unique_fields:
+                # Handle auto_now fields that were excluded from the main update
+                if hasattr(ctx, 'auto_now_fields') and existing_records:
+                    logger.debug(f"Performing separate update for auto_now fields: {ctx.auto_now_fields}")
+
+                    # Perform a separate bulk_update for the auto_now fields that were set via pre_save
+                    # This ensures they get saved to the database even though they were excluded from the main upsert
+                    try:
+                        # Use Django's base manager to bypass hooks and ensure the update happens
+                        base_manager = model_cls._base_manager
+                        auto_now_update_result = base_manager.bulk_update(
+                            existing_records, list(ctx.auto_now_fields)
+                        )
+                        logger.debug(f"Auto_now fields update completed with result: {auto_now_update_result}")
+                    except Exception as e:
+                        logger.error(f"Failed to update auto_now fields: {e}")
+                        # Don't raise the exception - the main operation succeeded
+
                 # 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')
+                    if hasattr(ctx, 'auto_now_fields'):
+                        delattr(ctx, 'auto_now_fields')
                     logger.debug(f"Restored update_fields: {update_fields}")
-                
+
                 # For upsert operations, reuse the existing/new records determination from BEFORE hooks
                 # This avoids duplicate queries and improves performance
                 if hasattr(ctx, 'upsert_existing_records') and hasattr(ctx, 'upsert_new_records'):
@@ -871,6 +889,7 @@ class HookQuerySetMixin:
         # Handle auto_now fields like Django's update_or_create does
         fields_set = set(fields)
         pk_fields = model_cls._meta.pk_fields
+        pk_field_names = [f.name for f in pk_fields]
         auto_now_fields = []
         custom_update_fields = []  # Fields that need pre_save() called on update
         logger.debug(f"Checking for auto_now and custom update fields in {model_cls.__name__}")
@@ -880,7 +899,7 @@ class HookQuerySetMixin:
             if hasattr(field, "auto_now") and field.auto_now:
                 logger.debug(f"Found auto_now field: {field.name}")
                 print(f"DEBUG: Found auto_now field: {field.name}")
-                if field.name not in fields_set and field.name not in pk_fields:
+                if field.name not in fields_set and field.name not in pk_field_names:
                     fields_set.add(field.name)
                     if field.name != field.attname:
                         fields_set.add(field.attname)
@@ -895,7 +914,7 @@ class HookQuerySetMixin:
             # Check for custom fields that might need pre_save() on update (like CurrentUserField)
             elif hasattr(field, 'pre_save'):
                 # Only call pre_save on fields that aren't already being updated
-                if field.name not in fields_set and field.name not in pk_fields:
+                if field.name not in fields_set and field.name not in pk_field_names:
                     custom_update_fields.append(field)
                     logger.debug(f"Found custom field with pre_save: {field.name}")
                     print(f"DEBUG: Found custom field with pre_save: {field.name}")
@@ -927,8 +946,8 @@ class HookQuerySetMixin:
                         # Only update the field if pre_save returned a new value
                         if new_value is not None:
                             setattr(obj, field.name, new_value)
-                            # Add this field to the update fields if it's not already there
-                            if field.name not in fields_set:
+                            # Add this field to the update fields if it's not already there and not a primary key
+                            if field.name not in fields_set and field.name not in pk_field_names:
                                 fields_set.add(field.name)
                                 fields.append(field.name)
                             logger.debug(f"Custom field {field.name} updated via pre_save() for object {obj.pk}")
@@ -1291,13 +1310,14 @@ class HookQuerySetMixin:
 
         return child_obj
 
-    def _mti_bulk_update(self, objs, fields, **kwargs):
+    def _mti_bulk_update(self, objs, fields, field_groups=None, inheritance_chain=None, **kwargs):
         """
         Custom bulk update implementation for MTI models.
         Updates each table in the inheritance chain efficiently using Django's batch_size.
         """
         model_cls = self.model
-        inheritance_chain = self._get_inheritance_chain()
+        if inheritance_chain is None:
+            inheritance_chain = self._get_inheritance_chain()
 
         # Remove custom hook kwargs before passing to Django internals
         django_kwargs = {
@@ -1341,17 +1361,18 @@ class HookQuerySetMixin:
         # Add custom fields that were updated to the fields list
         all_fields = list(fields) + list(auto_now_fields) + custom_update_fields
 
-        # Group fields by model in the inheritance chain
-        field_groups = {}
-        for field_name in all_fields:
-            field = model_cls._meta.get_field(field_name)
-            # Find which model in the inheritance chain this field belongs to
-            for model in inheritance_chain:
-                if field in model._meta.local_fields:
-                    if model not in field_groups:
-                        field_groups[model] = []
-                    field_groups[model].append(field_name)
-                    break
+        # Group fields by model in the inheritance chain (if not provided)
+        if field_groups is None:
+            field_groups = {}
+            for field_name in all_fields:
+                field = model_cls._meta.get_field(field_name)
+                # Find which model in the inheritance chain this field belongs to
+                for model in inheritance_chain:
+                    if field in model._meta.local_fields:
+                        if model not in field_groups:
+                            field_groups[model] = []
+                        field_groups[model].append(field_name)
+                        break
 
         # Process in batches
         batch_size = django_kwargs.get("batch_size") or len(objs)

{django_bulk_hooks-0.1.260 → django_bulk_hooks-0.1.262}/pyproject.toml

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