django-bulk-hooks 0.1.263__py3-none-any.whl → 0.1.265__py3-none-any.whl

django_bulk_hooks/manager.py

@@ -51,15 +51,18 @@ class BulkHookManager(models.Manager):
         )
 
     def bulk_update(
-        self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
+        self, objs, bypass_hooks=False, bypass_validation=False, **kwargs
     ):
         """
         Delegate to QuerySet's bulk_update implementation.
         This follows Django's pattern where Manager methods call QuerySet methods.
+
+        Note: Parameters like unique_fields, update_conflicts, update_fields, and ignore_conflicts
+        are not supported by bulk_update and will be ignored with a warning.
+        These parameters are only available in bulk_create for UPSERT operations.
         """
         return self.get_queryset().bulk_update(
             objs,
-            fields,
             bypass_hooks=bypass_hooks,
             bypass_validation=bypass_validation,
             **kwargs,
@@ -104,10 +107,8 @@ class BulkHookManager(models.Manager):
         Save a single object using the appropriate bulk operation.
         """
         if obj.pk:
-            self.bulk_update(
-                [obj],
-                fields=[field.name for field in obj._meta.fields if field.name != "id"],
-            )
+            # bulk_update now auto-detects changed fields
+            self.bulk_update([obj])
         else:
             self.bulk_create([obj])
         return obj

django_bulk_hooks/queryset.py

@@ -51,7 +51,11 @@ class HookQuerySetMixin:
             if obj.pk is not None:
                 # Cache all foreign key relationships by accessing them
                 for field in model_cls._meta.fields:
-                    if field.is_relation and not field.many_to_many and not field.one_to_many:
+                    if (
+                        field.is_relation
+                        and not field.many_to_many
+                        and not field.one_to_many
+                    ):
                         try:
                             # Access the related field to cache it before deletion
                             getattr(obj, field.name)
@@ -482,11 +486,19 @@ class HookQuerySetMixin:
         passed through to the correct logic. For MTI, only a subset of options may be supported.
         """
         model_cls = self.model
-        
-        print(f"DEBUG: bulk_create called for {model_cls.__name__} with {len(objs)} objects")
-        print(f"DEBUG: update_conflicts={update_conflicts}, unique_fields={unique_fields}, update_fields={update_fields}")
-        logger.debug(f"bulk_create called for {model_cls.__name__} with {len(objs)} objects")
-        logger.debug(f"update_conflicts={update_conflicts}, unique_fields={unique_fields}, update_fields={update_fields}")
+
+        print(
+            f"DEBUG: bulk_create called for {model_cls.__name__} with {len(objs)} objects"
+        )
+        print(
+            f"DEBUG: update_conflicts={update_conflicts}, unique_fields={unique_fields}, update_fields={update_fields}"
+        )
+        logger.debug(
+            f"bulk_create called for {model_cls.__name__} with {len(objs)} objects"
+        )
+        logger.debug(
+            f"update_conflicts={update_conflicts}, unique_fields={unique_fields}, update_fields={update_fields}"
+        )
 
         # When you bulk insert you don't get the primary keys back (if it's an
         # autoincrement, except if can_return_rows_from_bulk_insert=True), so
@@ -525,7 +537,7 @@ class HookQuerySetMixin:
         # Fire hooks before DB ops
         if not bypass_hooks:
             ctx = HookContext(model_cls, bypass_hooks=False)  # Pass bypass_hooks
-            
+
             if update_conflicts and unique_fields:
                 # For upsert operations, we need to determine which records will be created vs updated
                 # Check which records already exist in the database based on unique fields
@@ -535,7 +547,7 @@ class HookQuerySetMixin:
                 # Store the records for AFTER hooks to avoid duplicate queries
                 ctx.upsert_existing_records = existing_records
                 ctx.upsert_new_records = new_records
-                
+
                 # Build a filter to check which records already exist
                 unique_values = []
                 for obj in objs:
@@ -549,6 +561,7 @@ class HookQuerySetMixin:
                 if unique_values:
                     # Query the database to see which records already exist - SINGLE BULK QUERY
                     from django.db.models import Q
+
                     existing_filters = Q()
                     for unique_value in unique_values:
                         filter_kwargs = {}
@@ -558,7 +571,9 @@ class HookQuerySetMixin:
 
                     # Get all existing records in one query and create a lookup set
                     existing_records_lookup = set()
-                    for existing_record in model_cls.objects.filter(existing_filters).values_list(*unique_fields):
+                    for existing_record in model_cls.objects.filter(
+                        existing_filters
+                    ).values_list(*unique_fields):
                         # Convert tuple to a hashable key for lookup
                         existing_records_lookup.add(existing_record)
 
@@ -572,7 +587,10 @@ class HookQuerySetMixin:
                         # Check if this record already exists using our bulk lookup
                         if obj_unique_value:
                             # Convert object values to tuple for comparison with existing records
-                            obj_unique_tuple = tuple(obj_unique_value[field_name] for field_name in unique_fields)
+                            obj_unique_tuple = tuple(
+                                obj_unique_value[field_name]
+                                for field_name in unique_fields
+                            )
                             if obj_unique_tuple in existing_records_lookup:
                                 existing_records.append(obj)
                             else:
@@ -593,7 +611,7 @@ class HookQuerySetMixin:
                         elif hasattr(field, "auto_now_add") and field.auto_now_add:
                             if getattr(obj, field.name) is None:
                                 field.pre_save(obj, add=True)
-                
+
                 # For existing records, preserve their original auto_now values
                 # We'll need to fetch them from the database to preserve the timestamps
                 if existing_records:
@@ -606,7 +624,7 @@ class HookQuerySetMixin:
                                 unique_value[field_name] = getattr(obj, field_name)
                         if unique_value:
                             existing_unique_values.append(unique_value)
-                    
+
                     if existing_unique_values:
                         # Build filter to fetch existing records
                         existing_filters = Q()
@@ -615,14 +633,16 @@ class HookQuerySetMixin:
                             for field_name, value in unique_value.items():
                                 filter_kwargs[field_name] = value
                             existing_filters |= Q(**filter_kwargs)
-                        
+
                         # Fetch existing records to preserve their auto_now values
                         existing_db_records = model_cls.objects.filter(existing_filters)
                         existing_db_map = {}
                         for db_record in existing_db_records:
-                            key = tuple(getattr(db_record, field) for field in unique_fields)
+                            key = tuple(
+                                getattr(db_record, field) for field in unique_fields
+                            )
                             existing_db_map[key] = db_record
-                        
+
                         # For existing records, populate all fields from database and set auto_now fields
                         for obj in existing_records:
                             key = tuple(getattr(obj, field) for field in unique_fields)
@@ -631,28 +651,42 @@ class HookQuerySetMixin:
                                 # Copy all fields from the database record to ensure completeness
                                 populated_fields = []
                                 for field in model_cls._meta.local_fields:
-                                    if field.name != 'id':  # Don't overwrite the ID
+                                    if field.name != "id":  # Don't overwrite the ID
                                         db_value = getattr(db_record, field.name)
-                                        if db_value is not None:  # Only set non-None values
+                                        if (
+                                            db_value is not None
+                                        ):  # Only set non-None values
                                             setattr(obj, field.name, db_value)
                                             populated_fields.append(field.name)
-                                print(f"DEBUG: Populated {len(populated_fields)} fields for existing record: {populated_fields}")
-                                logger.debug(f"Populated {len(populated_fields)} fields for existing record: {populated_fields}")
-                                
+                                print(
+                                    f"DEBUG: Populated {len(populated_fields)} fields for existing record: {populated_fields}"
+                                )
+                                logger.debug(
+                                    f"Populated {len(populated_fields)} fields for existing record: {populated_fields}"
+                                )
+
                                 # Now set auto_now fields using Django's pre_save method
                                 for field in model_cls._meta.local_fields:
                                     if hasattr(field, "auto_now") and field.auto_now:
-                                        field.pre_save(obj, add=False)  # add=False for updates
-                                        print(f"DEBUG: Set {field.name} using pre_save for existing record {obj.pk}")
-                                        logger.debug(f"Set {field.name} using pre_save for existing record {obj.pk}")
-                
+                                        field.pre_save(
+                                            obj, add=False
+                                        )  # add=False for updates
+                                        print(
+                                            f"DEBUG: Set {field.name} using pre_save for existing record {obj.pk}"
+                                        )
+                                        logger.debug(
+                                            f"Set {field.name} using pre_save for existing record {obj.pk}"
+                                        )
+
                 # Remove duplicate code since we're now handling this above
-                
+
                 # 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}")
+                    logger.debug(
+                        f"Processing {len(existing_records)} existing records with update_fields: {update_fields}"
+                    )
 
                     # Identify auto_now fields
                     auto_now_fields = set()
@@ -669,24 +703,32 @@ class HookQuerySetMixin:
 
                         # 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]
+                        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"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}")
+                        logger.debug(
+                            f"Final update_fields for DB operation: {update_fields}"
+                        )
                     else:
                         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}")
-                
+                    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:
                     engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
-                
+
                 # Run appropriate BEFORE hooks based on what will happen
                 if new_records:
                     engine.run(model_cls, BEFORE_CREATE, new_records, ctx=ctx)
@@ -702,7 +744,7 @@ class HookQuerySetMixin:
                         elif hasattr(field, "auto_now_add") and field.auto_now_add:
                             if getattr(obj, field.name) is None:
                                 field.pre_save(obj, add=True)
-                
+
                 if not bypass_validation:
                     engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
                 engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
@@ -731,10 +773,16 @@ 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}")
-            
+            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,
@@ -743,15 +791,17 @@ 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:
                 # 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}")
+                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
@@ -761,29 +811,39 @@ class HookQuerySetMixin:
                         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}")
+                        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}")
+                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')
-                    if hasattr(ctx, 'auto_now_fields'):
-                        delattr(ctx, 'auto_now_fields')
+                    delattr(ctx, "original_update_fields")
+                    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'):
+                if hasattr(ctx, "upsert_existing_records") and hasattr(
+                    ctx, "upsert_new_records"
+                ):
                     existing_records = ctx.upsert_existing_records
                     new_records = ctx.upsert_new_records
-                    logger.debug(f"Reusing upsert record classification from BEFORE hooks: {len(existing_records)} existing, {len(new_records)} new")
+                    logger.debug(
+                        f"Reusing upsert record classification from BEFORE hooks: {len(existing_records)} existing, {len(new_records)} new"
+                    )
                 else:
                     # Fallback: determine records that actually exist after bulk operation
-                    logger.warning("Upsert record classification not found in context, performing fallback query")
+                    logger.warning(
+                        "Upsert record classification not found in context, performing fallback query"
+                    )
                     existing_records = []
                     new_records = []
 
@@ -800,6 +860,7 @@ class HookQuerySetMixin:
                     if unique_values:
                         # Query the database to see which records exist after bulk operation
                         from django.db.models import Q
+
                         existing_filters = Q()
                         for unique_value in unique_values:
                             filter_kwargs = {}
@@ -809,7 +870,9 @@ class HookQuerySetMixin:
 
                         # Get all existing records in one query and create a lookup set
                         existing_records_lookup = set()
-                        for existing_record in model_cls.objects.filter(existing_filters).values_list(*unique_fields):
+                        for existing_record in model_cls.objects.filter(
+                            existing_filters
+                        ).values_list(*unique_fields):
                             # Convert tuple to a hashable key for lookup
                             existing_records_lookup.add(existing_record)
 
@@ -818,12 +881,17 @@ class HookQuerySetMixin:
                             obj_unique_value = {}
                             for field_name in unique_fields:
                                 if hasattr(obj, field_name):
-                                    obj_unique_value[field_name] = getattr(obj, field_name)
+                                    obj_unique_value[field_name] = getattr(
+                                        obj, field_name
+                                    )
 
                             # Check if this record exists using our bulk lookup
                             if obj_unique_value:
                                 # Convert object values to tuple for comparison with existing records
-                                obj_unique_tuple = tuple(obj_unique_value[field_name] for field_name in unique_fields)
+                                obj_unique_tuple = tuple(
+                                    obj_unique_value[field_name]
+                                    for field_name in unique_fields
+                                )
                                 if obj_unique_tuple in existing_records_lookup:
                                     existing_records.append(obj)
                                 else:
@@ -846,12 +914,70 @@ class HookQuerySetMixin:
 
         return result
 
+    def _detect_changed_fields(self, objs):
+        """
+        Auto-detect which fields have changed by comparing objects with database values.
+        Returns a set of field names that have changed across all objects.
+        """
+        if not objs:
+            return set()
+
+        model_cls = self.model
+        changed_fields = set()
+
+        # Get primary key field names
+        pk_fields = [f.name for f in model_cls._meta.pk_fields]
+        if not pk_fields:
+            pk_fields = ["pk"]
+
+        # Get all object PKs
+        obj_pks = []
+        for obj in objs:
+            if hasattr(obj, "pk") and obj.pk is not None:
+                obj_pks.append(obj.pk)
+            else:
+                # Skip objects without PKs
+                continue
+
+        if not obj_pks:
+            return set()
+
+        # Fetch current database values for all objects
+        existing_objs = {
+            obj.pk: obj for obj in model_cls.objects.filter(pk__in=obj_pks)
+        }
+
+        # Compare each object's current values with database values
+        for obj in objs:
+            if obj.pk not in existing_objs:
+                continue
+
+            db_obj = existing_objs[obj.pk]
+
+            # Check all concrete fields for changes
+            for field in model_cls._meta.concrete_fields:
+                field_name = field.name
+
+                # Skip primary key fields
+                if field_name in pk_fields:
+                    continue
+
+                # Get current value from object
+                current_value = getattr(obj, field_name, None)
+                # Get database value
+                db_value = getattr(db_obj, field_name, None)
+
+                # Compare values (handle None cases)
+                if current_value != db_value:
+                    changed_fields.add(field_name)
+
+        return changed_fields
+
     @transaction.atomic
-    def bulk_update(
-        self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
-    ):
+    def bulk_update(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
         """
         Bulk update objects in the database with MTI support.
+        Automatically detects which fields have changed by comparing with database values.
         """
         model_cls = self.model
 
@@ -863,10 +989,16 @@ class HookQuerySetMixin:
                 f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
+        # Auto-detect changed fields by comparing with database values
+        changed_fields = self._detect_changed_fields(objs)
+        logger.debug(f"Auto-detected changed fields: {changed_fields}")
+
         logger.debug(
-            f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)} fields={fields}"
+            f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)} changed_fields={changed_fields}"
+        )
+        print(
+            f"DEBUG: bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)} changed_fields={changed_fields}"
         )
-        print(f"DEBUG: bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)} fields={fields}")
 
         # Check for MTI
         is_mti = False
@@ -887,12 +1019,14 @@ class HookQuerySetMixin:
             )  # Ensure originals is defined for after_update call
 
         # Handle auto_now fields like Django's update_or_create does
-        fields_set = set(fields)
+        fields_set = set(changed_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__}")
+        logger.debug(
+            f"Checking for auto_now and custom update 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
@@ -907,37 +1041,51 @@ class HookQuerySetMixin:
                     logger.debug(f"Added auto_now field {field.name} to fields list")
                     print(f"DEBUG: 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")
-                    print(f"DEBUG: Auto_now field {field.name} already in fields list or is PK")
+                    logger.debug(
+                        f"Auto_now field {field.name} already in fields list or is PK"
+                    )
+                    print(
+                        f"DEBUG: 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)")
             # Check for custom fields that might need pre_save() on update (like CurrentUserField)
-            elif hasattr(field, 'pre_save'):
+            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_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}")
-        
+
         logger.debug(f"Auto_now fields detected: {auto_now_fields}")
         print(f"DEBUG: 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()
-            print(f"DEBUG: Setting auto_now fields {auto_now_fields} to current time: {current_time}")
-            logger.debug(f"Setting auto_now fields {auto_now_fields} to current time: {current_time}")
+            print(
+                f"DEBUG: Setting auto_now fields {auto_now_fields} to current time: {current_time}"
+            )
+            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)
-                    print(f"DEBUG: Set {field_name} to {current_time} for object {obj.pk}")
+                    print(
+                        f"DEBUG: Set {field_name} to {current_time} for object {obj.pk}"
+                    )
 
         # Call pre_save() on custom fields that need update handling
         if custom_update_fields:
-            logger.debug(f"Calling pre_save() on custom update fields: {[f.name for f in custom_update_fields]}")
-            print(f"DEBUG: Calling pre_save() on custom update fields: {[f.name for f in custom_update_fields]}")
+            logger.debug(
+                f"Calling pre_save() on custom update fields: {[f.name for f in custom_update_fields]}"
+            )
+            print(
+                f"DEBUG: Calling pre_save() on custom update fields: {[f.name for f in custom_update_fields]}"
+            )
             for obj in objs:
                 for field in custom_update_fields:
                     try:
@@ -947,39 +1095,60 @@ class HookQuerySetMixin:
                         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 and not a primary key
-                            if field.name not in fields_set and field.name not in pk_field_names:
+                            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}")
-                            print(f"DEBUG: Custom field {field.name} updated via pre_save() for object {obj.pk}")
+                            logger.debug(
+                                f"Custom field {field.name} updated via pre_save() for object {obj.pk}"
+                            )
+                            print(
+                                f"DEBUG: Custom field {field.name} updated via pre_save() for object {obj.pk}"
+                            )
                     except Exception as e:
-                        logger.warning(f"Failed to call pre_save() on custom field {field.name}: {e}")
-                        print(f"DEBUG: Failed to call pre_save() on custom field {field.name}: {e}")
+                        logger.warning(
+                            f"Failed to call pre_save() on custom field {field.name}: {e}"
+                        )
+                        print(
+                            f"DEBUG: Failed to call pre_save() on custom field {field.name}: {e}"
+                        )
 
         # Handle MTI models differently
         if is_mti:
-            result = self._mti_bulk_update(objs, fields, **kwargs)
+            result = self._mti_bulk_update(objs, list(fields_set), **kwargs)
         else:
             # For single-table models, use Django's built-in bulk_update
-            django_kwargs = {
-                k: v
-                for k, v in kwargs.items()
-                if k not in ["bypass_hooks", "bypass_validation"]
-            }
+            # Filter out parameters that are not supported by Django's bulk_update
+            unsupported_params = ["unique_fields", "update_conflicts", "update_fields", "ignore_conflicts"]
+            django_kwargs = {}
+            for k, v in kwargs.items():
+                if k in unsupported_params:
+                    logger.warning(
+                        f"Parameter '{k}' is not supported by bulk_update. "
+                        f"This parameter is only available in bulk_create for UPSERT operations."
+                    )
+                    print(f"WARNING: Parameter '{k}' is not supported by bulk_update")
+                elif k not in ["bypass_hooks", "bypass_validation"]:
+                    django_kwargs[k] = v
             logger.debug("Calling Django bulk_update")
             print("DEBUG: Calling Django bulk_update")
             # 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}")
+            logger.debug(
+                f"Building value map for {len(objs)} objects with fields: {list(fields_set)}"
+            )
             for obj in objs:
                 if obj.pk is None:
                     continue
                 field_values = {}
-                for field_name in fields:
+                for field_name in fields_set:
                     # 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]}")
+                        logger.debug(
+                            f"Object {obj.pk} {field_name}: {field_values[field_name]}"
+                        )
                 if field_values:
                     value_map[obj.pk] = field_values
 
@@ -988,7 +1157,7 @@ class HookQuerySetMixin:
                 set_bulk_update_value_map(value_map)
 
             try:
-                result = super().bulk_update(objs, fields, **django_kwargs)
+                result = super().bulk_update(objs, list(fields_set), **django_kwargs)
             finally:
                 # Always clear after the internal update() path finishes
                 set_bulk_update_value_map(None)
@@ -1310,7 +1479,9 @@ class HookQuerySetMixin:
 
         return child_obj
 
-    def _mti_bulk_update(self, objs, fields, field_groups=None, inheritance_chain=None, **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.
@@ -1319,12 +1490,18 @@ class HookQuerySetMixin:
         if inheritance_chain is None:
             inheritance_chain = self._get_inheritance_chain()
 
-        # Remove custom hook kwargs before passing to Django internals
-        django_kwargs = {
-            k: v
-            for k, v in kwargs.items()
-            if k not in ["bypass_hooks", "bypass_validation"]
-        }
+        # Remove custom hook kwargs and unsupported parameters before passing to Django internals
+        unsupported_params = ["unique_fields", "update_conflicts", "update_fields", "ignore_conflicts"]
+        django_kwargs = {}
+        for k, v in kwargs.items():
+            if k in unsupported_params:
+                logger.warning(
+                    f"Parameter '{k}' is not supported by bulk_update. "
+                    f"This parameter is only available in bulk_create for UPSERT operations."
+                )
+                print(f"WARNING: Parameter '{k}' is not supported by bulk_update")
+            elif k not in ["bypass_hooks", "bypass_validation"]:
+                django_kwargs[k] = v
 
         # Safety check to prevent infinite recursion
         if len(inheritance_chain) > 10:  # Arbitrary limit to prevent infinite loops
@@ -1341,15 +1518,19 @@ class HookQuerySetMixin:
                     if hasattr(field, "auto_now") and field.auto_now:
                         field.pre_save(obj, add=False)
                     # Check for custom fields that might need pre_save() on update (like CurrentUserField)
-                    elif hasattr(field, 'pre_save') and field.name not in fields:
+                    elif hasattr(field, "pre_save") and field.name not in fields:
                         try:
                             new_value = field.pre_save(obj, add=False)
                             if new_value is not None:
                                 setattr(obj, field.name, new_value)
                                 custom_update_fields.append(field.name)
-                                logger.debug(f"Custom field {field.name} updated via pre_save() for MTI object {obj.pk}")
+                                logger.debug(
+                                    f"Custom field {field.name} updated via pre_save() for MTI object {obj.pk}"
+                                )
                         except Exception as e:
-                            logger.warning(f"Failed to call pre_save() on custom field {field.name} in MTI: {e}")
+                            logger.warning(
+                                f"Failed to call pre_save() on custom field {field.name} in MTI: {e}"
+                            )
 
         # Add auto_now fields to the fields list so they get updated in the database
         auto_now_fields = set()
@@ -1527,7 +1708,11 @@ class HookQuerySetMixin:
                 if obj.pk is not None:
                     # Cache all foreign key relationships by accessing them
                     for field in model_cls._meta.fields:
-                        if field.is_relation and not field.many_to_many and not field.one_to_many:
+                        if (
+                            field.is_relation
+                            and not field.many_to_many
+                            and not field.one_to_many
+                        ):
                             try:
                                 # Access the related field to cache it before deletion
                                 getattr(obj, field.name)

{django_bulk_hooks-0.1.263.dist-info → django_bulk_hooks-0.1.265.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.263
+Version: 0.1.265
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks
@@ -114,7 +114,7 @@ Account.objects.bulk_create(accounts)
 # Bulk update - triggers BEFORE_UPDATE and AFTER_UPDATE hooks
 for account in accounts:
     account.balance *= 1.1
-Account.objects.bulk_update(accounts, ['balance'])
+Account.objects.bulk_update(accounts)  # fields are auto-detected
 
 # Bulk delete - triggers BEFORE_DELETE and AFTER_DELETE hooks
 Account.objects.bulk_delete(accounts)
@@ -200,7 +200,7 @@ account.delete()
 ```python
 # These also trigger hooks
 Account.objects.bulk_create(accounts)
-Account.objects.bulk_update(accounts, ['balance'])
+Account.objects.bulk_update(accounts)  # fields are auto-detected
 Account.objects.bulk_delete(accounts)
 ```
 
@@ -239,7 +239,7 @@ accounts = [account1, account2, account3]  # IDs: 1, 2, 3
 reordered = [account3, account1, account2]  # IDs: 3, 1, 2
 
 # The hook will still receive properly paired old/new records
-LoanAccount.objects.bulk_update(reordered, ['balance'])
+LoanAccount.objects.bulk_update(reordered)  # fields are auto-detected
 ```
 
 ## 🧩 Integration with Other Managers

{django_bulk_hooks-0.1.263.dist-info → django_bulk_hooks-0.1.265.dist-info}/RECORD

@@ -6,12 +6,12 @@ django_bulk_hooks/decorators.py,sha256=k70-BzWwS3wZu_uph5B5qXd6YpwXLQ9hMpOzPUy6i
 django_bulk_hooks/engine.py,sha256=M3b7Rcb65PYAZTLfWrIRi99BUBPgSLCryL3MSjMVlfQ,2663
 django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
 django_bulk_hooks/handler.py,sha256=Bx-W6yyiciKMyy-BRxUt3CmRPCrX9_LhQgU-5LaJTjg,6019
-django_bulk_hooks/manager.py,sha256=nfWiwU5-yAoxdnQsUMohxtyCpkV0MBv6X3wmipr9eQY,3697
+django_bulk_hooks/manager.py,sha256=mk2RYm-iBk7xYTcYfuo7XPHJbPP5TCTns5IxJMwRY2M,3867
 django_bulk_hooks/models.py,sha256=WtSfc4GBOG_oOt8n37cVvid0MtFIGze9JYKSixil2y0,4370
 django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
-django_bulk_hooks/queryset.py,sha256=-Fuo6K4f4Mhwq9lUkAE4rpaVUHAvGASgktYJRjg-wXY,77120
+django_bulk_hooks/queryset.py,sha256=8DWTupyB0vbqKyJZtgAU7G6COTjn0YFkNctE-GQzIrM,82882
 django_bulk_hooks/registry.py,sha256=GRUTGVQEO2sdkC9OaZ9Q3U7mM-3Ix83uTyvrlTtpatw,1317
-django_bulk_hooks-0.1.263.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.263.dist-info/METADATA,sha256=XZX4cOne2oJcQ_hS1Tj1jvfXKSb6TNNQgvvBCW2VPNo,9070
-django_bulk_hooks-0.1.263.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.1.263.dist-info/RECORD,,
+django_bulk_hooks-0.1.265.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.265.dist-info/METADATA,sha256=jzUzQDfaNXu3tfCp66T_-Af_oTUlbzCVe93Zy6QKDKk,9115
+django_bulk_hooks-0.1.265.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.1.265.dist-info/RECORD,,