django-bulk-hooks 0.1.266__tar.gz → 0.1.268__tar.gz

{django_bulk_hooks-0.1.266 → django_bulk_hooks-0.1.268}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.266
+Version: 0.1.268
 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.266 → django_bulk_hooks-0.1.268}/django_bulk_hooks/manager.py

@@ -8,18 +8,18 @@ class BulkHookManager(models.Manager):
         # Use super().get_queryset() to let Django and MRO build the queryset
         # This ensures cooperation with other managers
         base_queryset = super().get_queryset()
-        
+
         # If the base queryset already has hook functionality, return it as-is
         if isinstance(base_queryset, HookQuerySetMixin):
             return base_queryset
-        
+
         # Otherwise, create a new HookQuerySet with the same parameters
         # This is much simpler and avoids dynamic class creation issues
         return HookQuerySet(
             model=base_queryset.model,
             query=base_queryset.query,
             using=base_queryset._db,
-            hints=base_queryset._hints
+            hints=base_queryset._hints,
         )
 
     def bulk_create(
@@ -50,9 +50,7 @@ class BulkHookManager(models.Manager):
             **kwargs,
         )
 
-    def bulk_update(
-        self, objs, bypass_hooks=False, bypass_validation=False, **kwargs
-    ):
+    def bulk_update(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.

{django_bulk_hooks-0.1.266 → django_bulk_hooks-0.1.268}/django_bulk_hooks/queryset.py

@@ -485,19 +485,12 @@ class HookQuerySetMixin:
         but supports multi-table inheritance (MTI) models and hooks. All arguments are supported and
         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}"
+        model_cls, ctx, originals = self._setup_bulk_operation(
+            objs, "bulk_create", require_pks=False,
+            bypass_hooks=bypass_hooks, bypass_validation=bypass_validation,
+            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
@@ -518,26 +511,13 @@ class HookQuerySetMixin:
         if not objs:
             return objs
 
-        if any(not isinstance(obj, model_cls) for obj in objs):
-            raise TypeError(
-                f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
-            )
+        self._validate_objects(objs, require_pks=False, operation_name="bulk_create")
 
         # Check for MTI - if we detect multi-table inheritance, we need special handling
-        # This follows Django's approach: check that the parents share the same concrete model
-        # with our model to detect the inheritance pattern ConcreteGrandParent ->
-        # MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy would not
-        # identify that case as involving multiple tables.
-        is_mti = False
-        for parent in model_cls._meta.all_parents:
-            if parent._meta.concrete_model is not model_cls._meta.concrete_model:
-                is_mti = True
-                break
+        is_mti = self._is_multi_table_inheritance()
 
         # 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
@@ -604,13 +584,7 @@ class HookQuerySetMixin:
 
                 # Handle auto_now fields intelligently for upsert operations
                 # Only set auto_now fields on records that will actually be created
-                for obj in new_records:
-                    for field in model_cls._meta.local_fields:
-                        if hasattr(field, "auto_now") and field.auto_now:
-                            field.pre_save(obj, add=True)
-                        elif hasattr(field, "auto_now_add") and field.auto_now_add:
-                            if getattr(obj, field.name) is None:
-                                field.pre_save(obj, add=True)
+                self._handle_auto_now_fields(new_records, add=True)
 
                 # For existing records, preserve their original auto_now values
                 # We'll need to fetch them from the database to preserve the timestamps
@@ -737,19 +711,12 @@ class HookQuerySetMixin:
             else:
                 # For regular create operations, run create hooks before DB ops
                 # Handle auto_now fields normally for new records
-                for obj in objs:
-                    for field in model_cls._meta.local_fields:
-                        if hasattr(field, "auto_now") and field.auto_now:
-                            field.pre_save(obj, add=True)
-                        elif hasattr(field, "auto_now_add") and field.auto_now_add:
-                            if getattr(obj, field.name) is None:
-                                field.pre_save(obj, add=True)
+                self._handle_auto_now_fields(objs, add=True)
 
                 if not bypass_validation:
                     engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
                 engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
         else:
-            ctx = HookContext(model_cls, bypass_hooks=True)  # Pass bypass_hooks
             logger.debug("bulk_create bypassed hooks")
 
         # For MTI models, we need to handle them specially
@@ -975,217 +942,491 @@ class HookQuerySetMixin:
 
     @transaction.atomic
     def bulk_update(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
+        if not objs:
+            return []
+
+        self._validate_objects(objs, require_pks=True, operation_name="bulk_update")
+
+        changed_fields = self._detect_changed_fields(objs)
+        is_mti = self._is_multi_table_inheritance()
+        hook_context, originals = self._init_hook_context(bypass_hooks, objs, "bulk_update")
+
+        fields_set, auto_now_fields, custom_update_fields = self._prepare_update_fields(
+            changed_fields
+        )
+
+        self._apply_auto_now_fields(objs, auto_now_fields)
+        self._apply_custom_update_fields(objs, custom_update_fields, fields_set)
+
+        if is_mti:
+            return self._mti_bulk_update(objs, list(fields_set), **kwargs)
+        else:
+            return self._single_table_bulk_update(
+                objs, fields_set, auto_now_fields, **kwargs
+            )
+
+    def _apply_custom_update_fields(self, objs, custom_update_fields, fields_set):
         """
-        Bulk update objects in the database with MTI support.
-        Automatically detects which fields have changed by comparing with database values.
+        Call pre_save() for custom fields that require update handling
+        (e.g., CurrentUserField) and update both the objects and the field set.
+
+        Args:
+            objs (list[Model]): The model instances being updated.
+            custom_update_fields (list[Field]): Fields that define a pre_save() hook.
+            fields_set (set[str]): The overall set of fields to update, mutated in place.
         """
+        if not custom_update_fields:
+            return
+
         model_cls = self.model
+        pk_field_names = [f.name for f in model_cls._meta.pk_fields]
 
-        if not objs:
-            return []
+        logger.debug(
+            "Applying pre_save() on custom update fields: %s",
+            [f.name for f in custom_update_fields],
+        )
+
+        for obj in objs:
+            for field in custom_update_fields:
+                try:
+                    # Call pre_save with add=False (since this is an update)
+                    new_value = field.pre_save(obj, add=False)
+
+                    # Only assign if pre_save returned something
+                    if new_value is not None:
+                        setattr(obj, field.name, new_value)
+
+                        # Ensure this field is included in the update set
+                        if (
+                            field.name not in fields_set
+                            and field.name not in pk_field_names
+                        ):
+                            fields_set.add(field.name)
 
-        if any(not isinstance(obj, model_cls) for obj in objs):
+                        logger.debug(
+                            "Custom field %s updated via pre_save() for object %s",
+                            field.name,
+                            obj.pk,
+                        )
+
+                except Exception as e:
+                    logger.warning(
+                        "Failed to call pre_save() on custom field %s for object %s: %s",
+                        field.name,
+                        getattr(obj, "pk", None),
+                        e,
+                    )
+
+    def _single_table_bulk_update(self, objs, fields_set, auto_now_fields, **kwargs):
+        """
+        Perform bulk_update for single-table models, handling Django semantics
+        for kwargs and setting a value map for hook execution.
+
+        Args:
+            objs (list[Model]): The model instances being updated.
+            fields_set (set[str]): The names of fields to update.
+            auto_now_fields (list[str]): Names of auto_now fields included in update.
+            **kwargs: Extra arguments (only Django-supported ones are passed through).
+
+        Returns:
+            list[Model]: The updated model instances.
+        """
+        # Strip out unsupported bulk_update kwargs
+        django_kwargs = self._filter_django_kwargs(kwargs)
+
+        # Build a value map: {pk -> {field: raw_value}} for later hook use
+        value_map = self._build_value_map(objs, fields_set, auto_now_fields)
+
+        if value_map:
+            set_bulk_update_value_map(value_map)
+
+        try:
+            logger.debug(
+                "Calling Django bulk_update for %d objects on fields %s",
+                len(objs),
+                list(fields_set),
+            )
+            return super().bulk_update(objs, list(fields_set), **django_kwargs)
+        finally:
+            # Always clear thread-local state
+            set_bulk_update_value_map(None)
+
+    def _filter_django_kwargs(self, kwargs):
+        """
+        Remove unsupported arguments before passing to Django's bulk_update.
+        """
+        unsupported = {
+            "unique_fields",
+            "update_conflicts",
+            "update_fields",
+            "ignore_conflicts",
+        }
+        passthrough = {}
+        for k, v in kwargs.items():
+            if k in unsupported:
+                logger.warning(
+                    "Parameter '%s' is not supported by bulk_update. "
+                    "It is only available for bulk_create UPSERT operations.",
+                    k,
+                )
+            elif k not in {"bypass_hooks", "bypass_validation"}:
+                passthrough[k] = v
+        return passthrough
+
+    def _build_value_map(self, objs, fields_set, auto_now_fields):
+        """
+        Build a mapping of {pk -> {field_name: raw_value}} for hook processing.
+
+        Expressions are not included; only concrete values assigned on the object.
+        """
+        value_map = {}
+        for obj in objs:
+            if obj.pk is None:
+                continue  # skip unsaved objects
+            field_values = {}
+            for field_name in fields_set:
+                value = getattr(obj, field_name)
+                field_values[field_name] = value
+                if field_name in auto_now_fields:
+                    logger.debug("Object %s %s=%s", obj.pk, field_name, value)
+            if field_values:
+                value_map[obj.pk] = field_values
+
+        logger.debug("Built value_map for %d objects", len(value_map))
+        return value_map
+
+    def _validate_objects(self, objs, require_pks=False, operation_name="bulk_update"):
+        """
+        Validate that all objects are instances of this queryset's model.
+
+        Args:
+            objs (list): Objects to validate
+            require_pks (bool): Whether to validate that objects have primary keys
+            operation_name (str): Name of the operation for error messages
+        """
+        model_cls = self.model
+
+        # Type check
+        invalid_types = {
+            type(obj).__name__ for obj in objs if not isinstance(obj, model_cls)
+        }
+        if invalid_types:
             raise TypeError(
-                f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
+                f"{operation_name} expected instances of {model_cls.__name__}, "
+                f"but got {invalid_types}"
             )
 
-        # 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}")
+        # Primary key check (optional, for operations that require saved objects)
+        if require_pks:
+            missing_pks = [obj for obj in objs if obj.pk is None]
+            if missing_pks:
+                raise ValueError(
+                    f"{operation_name} cannot operate on unsaved {model_cls.__name__} instances. "
+                    f"{len(missing_pks)} object(s) have no primary key."
+                )
 
         logger.debug(
-            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}"
+            "Validated %d %s objects for %s",
+            len(objs),
+            model_cls.__name__,
+            operation_name,
         )
 
-        # Check for MTI
-        is_mti = False
-        for parent in model_cls._meta.all_parents:
-            if parent._meta.concrete_model is not model_cls._meta.concrete_model:
-                is_mti = True
-                break
+    def _init_hook_context(self, bypass_hooks: bool, objs, operation_name="bulk_update"):
+        """
+        Initialize the hook context for bulk operations.
 
-        if not bypass_hooks:
-            logger.debug("bulk_update: hooks will run in update()")
-            ctx = HookContext(model_cls, bypass_hooks=False)
-            originals = [None] * len(objs)  # Placeholder for after_update call
-        else:
-            logger.debug("bulk_update: hooks bypassed")
+        Args:
+            bypass_hooks (bool): Whether to bypass hooks
+            objs (list): List of objects being operated on
+            operation_name (str): Name of the operation for logging
+
+        Returns:
+            (HookContext, list): The hook context and a placeholder list
+            for 'originals', which can be populated later if needed for
+            after_update hooks.
+        """
+        model_cls = self.model
+
+        if bypass_hooks:
+            logger.debug("%s: hooks bypassed for %s", operation_name, model_cls.__name__)
             ctx = HookContext(model_cls, bypass_hooks=True)
-            originals = [None] * len(
-                objs
-            )  # Ensure originals is defined for after_update call
+        else:
+            logger.debug("%s: hooks enabled for %s", operation_name, model_cls.__name__)
+            ctx = HookContext(model_cls, bypass_hooks=False)
+
+        # Keep `originals` aligned with objs to support later hook execution.
+        originals = [None] * len(objs)
+
+        return ctx, originals
 
-        # Handle auto_now fields like Django's update_or_create does
+    def _prepare_update_fields(self, changed_fields):
+        """
+        Determine the final set of fields to update, including auto_now
+        fields and custom fields that require pre_save() on updates.
+
+        Args:
+            changed_fields (Iterable[str]): Fields detected as changed.
+
+        Returns:
+            tuple:
+                fields_set (set): All fields that should be updated.
+                auto_now_fields (list[str]): Fields that require auto_now behavior.
+                custom_update_fields (list[Field]): Fields with pre_save hooks to call.
+        """
+        model_cls = self.model
         fields_set = set(changed_fields)
-        pk_fields = model_cls._meta.pk_fields
-        pk_field_names = [f.name for f in pk_fields]
+        pk_field_names = [f.name for f in model_cls._meta.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__}"
-        )
+        custom_update_fields = []
+
         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}")
-                print(f"DEBUG: Found auto_now field: {field.name}")
+            # Handle auto_now fields
+            if getattr(field, "auto_now", False):
                 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:
+                    if field.name != field.attname:  # handle attname vs name
                         fields_set.add(field.attname)
                     auto_now_fields.append(field.name)
-                    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"
-                    )
-            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)
+                    logger.debug("Added auto_now field %s to update set", field.name)
+
+            # Skip auto_now_add (only applies at creation time)
+            elif getattr(field, "auto_now_add", False):
+                continue
+
+            # Handle custom pre_save fields
             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(
+                        "Marked custom field %s for pre_save update", field.name
+                    )
 
-        logger.debug(f"Auto_now fields detected: {auto_now_fields}")
-        print(f"DEBUG: Auto_now fields detected: {auto_now_fields}")
+        logger.debug(
+            "Prepared update fields: fields_set=%s, auto_now_fields=%s, custom_update_fields=%s",
+            fields_set,
+            auto_now_fields,
+            [f.name for f in custom_update_fields],
+        )
 
-        # Set auto_now field values to current timestamp
-        if auto_now_fields:
-            from django.utils import timezone
+        return fields_set, auto_now_fields, custom_update_fields
 
-            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}"
-            )
-            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}"
-                    )
+    def _apply_auto_now_fields(self, objs, auto_now_fields, add=False):
+        """
+        Apply the current timestamp to all auto_now fields on each object.
 
-        # 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]}"
-            )
-            for obj in objs:
-                for field in custom_update_fields:
-                    try:
-                        # Call pre_save with add=False to indicate this is an update
-                        new_value = field.pre_save(obj, add=False)
-                        # 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 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)
-                            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}"
-                        )
+        Args:
+            objs (list[Model]): The model instances being processed.
+            auto_now_fields (list[str]): Field names that require auto_now behavior.
+            add (bool): Whether this is for creation (add=True) or update (add=False).
+        """
+        if not auto_now_fields:
+            return
 
-        # Handle MTI models differently
-        if is_mti:
-            result = self._mti_bulk_update(objs, list(fields_set), **kwargs)
-        else:
-            # For single-table models, use Django's built-in bulk_update
-            # Filter out parameters that are not supported by Django's bulk_update
-            unsupported_params = ["unique_fields", "update_conflicts", "update_fields", "ignore_conflicts"]
-            django_kwargs = {}
-
-            # Check if all objects have primary keys set before proceeding
-            if not all(obj._is_pk_set() for obj in objs):
-                missing_pk_count = sum(1 for obj in objs if not obj._is_pk_set())
-                logger.error(
-                    f"bulk_update failed: {missing_pk_count} out of {len(objs)} objects don't have primary keys set. "
-                    "All objects must be saved to the database before bulk_update can be used."
-                )
-                print(f"ERROR: {missing_pk_count} objects don't have primary keys set")
-                raise ValueError(
-                    f"All bulk_update() objects must have a primary key set. "
-                    f"{missing_pk_count} out of {len(objs)} objects are missing primary keys."
-                )
+        from django.utils import timezone
 
-            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: {list(fields_set)}"
-            )
+        current_time = timezone.now()
+
+        logger.debug(
+            "Setting auto_now fields %s to %s for %d objects (add=%s)",
+            auto_now_fields,
+            current_time,
+            len(objs),
+            add,
+        )
+
+        for obj in objs:
+            for field_name in auto_now_fields:
+                setattr(obj, field_name, current_time)
+
+    def _handle_auto_now_fields(self, objs, add=False):
+        """
+        Handle auto_now and auto_now_add fields for objects.
+
+        Args:
+            objs (list[Model]): The model instances being processed.
+            add (bool): Whether this is for creation (add=True) or update (add=False).
+
+        Returns:
+            list[str]: Names of auto_now fields that were handled.
+        """
+        model_cls = self.model
+        handled_fields = []
+
+        for obj in objs:
+            for field in model_cls._meta.local_fields:
+                # Handle auto_now_add only during creation
+                if add and hasattr(field, "auto_now_add") and field.auto_now_add:
+                    if getattr(obj, field.name) is None:
+                        field.pre_save(obj, add=True)
+                    handled_fields.append(field.name)
+                # Handle auto_now during creation or update
+                elif hasattr(field, "auto_now") and field.auto_now:
+                    field.pre_save(obj, add=add)
+                    handled_fields.append(field.name)
+
+        return list(set(handled_fields))  # Remove duplicates
+
+    def _execute_hooks_with_operation(self, operation_func, validate_hook, before_hook, after_hook, objs, originals=None, ctx=None, bypass_hooks=False, bypass_validation=False):
+        """
+        Execute the complete hook lifecycle around a database operation.
+
+        Args:
+            operation_func (callable): The database operation to execute
+            validate_hook: Hook constant for validation
+            before_hook: Hook constant for before operation
+            after_hook: Hook constant for after operation
+            objs (list): Objects being operated on
+            originals (list, optional): Original objects for comparison hooks
+            ctx: Hook context
+            bypass_hooks (bool): Whether to skip hooks
+            bypass_validation (bool): Whether to skip validation hooks
+
+        Returns:
+            The result of the database operation
+        """
+        model_cls = self.model
+
+        # Run validation hooks first (if not bypassed)
+        if not bypass_validation and validate_hook:
+            engine.run(model_cls, validate_hook, objs, ctx=ctx)
+
+        # Run before hooks (if not bypassed)
+        if not bypass_hooks and before_hook:
+            engine.run(model_cls, before_hook, objs, originals, ctx=ctx)
+
+        # Execute the database operation
+        result = operation_func()
+
+        # Run after hooks (if not bypassed)
+        if not bypass_hooks and after_hook:
+            engine.run(model_cls, after_hook, objs, originals, ctx=ctx)
+
+        return result
+
+    def _log_bulk_operation_start(self, operation_name, objs, **kwargs):
+        """
+        Log the start of a bulk operation with consistent formatting.
+
+        Args:
+            operation_name (str): Name of the operation (e.g., "bulk_create")
+            objs (list): Objects being operated on
+            **kwargs: Additional parameters to log
+        """
+        model_cls = self.model
+
+        # Build parameter string for additional kwargs
+        param_str = ""
+        if kwargs:
+            param_parts = []
+            for key, value in kwargs.items():
+                if isinstance(value, (list, tuple)):
+                    param_parts.append(f"{key}={value}")
+                else:
+                    param_parts.append(f"{key}={value}")
+            param_str = f", {', '.join(param_parts)}"
+
+        # Use both print and logger for consistency with existing patterns
+        print(f"DEBUG: {operation_name} called for {model_cls.__name__} with {len(objs)} objects{param_str}")
+        logger.debug(f"{operation_name} called for {model_cls.__name__} with {len(objs)} objects{param_str}")
+
+    def _execute_delete_hooks_with_operation(self, operation_func, objs, ctx=None, bypass_hooks=False, bypass_validation=False):
+        """
+        Execute hooks for delete operations with special field caching logic.
+
+        Args:
+            operation_func (callable): The delete operation to execute
+            objs (list): Objects being deleted
+            ctx: Hook context
+            bypass_hooks (bool): Whether to skip hooks
+            bypass_validation (bool): Whether to skip validation hooks
+
+        Returns:
+            The result of the delete operation
+        """
+        model_cls = self.model
+
+        # Run validation hooks first (if not bypassed)
+        if not bypass_validation:
+            engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
+
+        # Run before hooks (if not bypassed)
+        if not bypass_hooks:
+            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
+
+            # Before deletion, ensure all related fields are properly cached
+            # to avoid DoesNotExist errors in AFTER_DELETE hooks
             for obj in objs:
-                if obj.pk is None:
-                    continue
-                field_values = {}
-                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]}"
-                        )
-                if field_values:
-                    value_map[obj.pk] = field_values
-
-            # Make the value map available to the subsequent update() call
-            if value_map:
-                set_bulk_update_value_map(value_map)
-
-            try:
-                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)
-            logger.debug(f"Django bulk_update done: {result}")
-
-        # Note: We don't run AFTER_UPDATE hooks here to prevent double execution
-        # The update() method will handle all hook execution based on thread-local state
+                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
+                        ):
+                            try:
+                                # Access the related field to cache it before deletion
+                                getattr(obj, field.name)
+                            except Exception:
+                                # If we can't access the field (e.g., already deleted, no permission, etc.)
+                                # continue with other fields
+                                pass
+
+        # Execute the database operation
+        result = operation_func()
+
+        # Run after hooks (if not bypassed)
         if not bypass_hooks:
-            logger.debug("bulk_update: skipping AFTER_UPDATE (update() will handle)")
-        else:
-            logger.debug("bulk_update: hooks bypassed")
+            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
 
         return result
 
+    def _setup_bulk_operation(self, objs, operation_name, require_pks=False, bypass_hooks=False, bypass_validation=False, **log_kwargs):
+        """
+        Common setup logic for bulk operations.
+
+        Args:
+            objs (list): Objects to operate on
+            operation_name (str): Name of the operation for logging and validation
+            require_pks (bool): Whether objects must have primary keys
+            bypass_hooks (bool): Whether to bypass hooks
+            bypass_validation (bool): Whether to bypass validation
+            **log_kwargs: Additional parameters to log
+
+        Returns:
+            tuple: (model_cls, ctx, originals)
+        """
+        # Log operation start
+        self._log_bulk_operation_start(operation_name, objs, **log_kwargs)
+
+        # Validate objects
+        self._validate_objects(objs, require_pks=require_pks, operation_name=operation_name)
+
+        # Initialize hook context
+        ctx, originals = self._init_hook_context(bypass_hooks, objs, operation_name)
+
+        return self.model, ctx, originals
+
+    def _is_multi_table_inheritance(self) -> bool:
+        """
+        Determine whether this model uses multi-table inheritance (MTI).
+        Returns True if the model has any concrete parent models other than itself.
+        """
+        model_cls = self.model
+        for parent in model_cls._meta.all_parents:
+            if parent._meta.concrete_model is not model_cls._meta.concrete_model:
+                logger.debug(
+                    "%s detected as MTI model (parent: %s)",
+                    model_cls.__name__,
+                    getattr(parent, "__name__", str(parent)),
+                )
+                return True
+
+        logger.debug("%s is not an MTI model", model_cls.__name__)
+        return False
+
     def _detect_modified_fields(self, new_instances, original_instances):
         """
         Detect fields that were modified during BEFORE_UPDATE hooks by comparing
@@ -1504,21 +1745,13 @@ class HookQuerySetMixin:
         if inheritance_chain is None:
             inheritance_chain = self._get_inheritance_chain()
 
-        # Check if all objects have primary keys set before proceeding
-        if not all(obj._is_pk_set() for obj in objs):
-            missing_pk_count = sum(1 for obj in objs if not obj._is_pk_set())
-            logger.error(
-                f"MTI bulk_update failed: {missing_pk_count} out of {len(objs)} objects don't have primary keys set. "
-                "All objects must be saved to the database before bulk_update can be used."
-            )
-            print(f"ERROR: {missing_pk_count} objects don't have primary keys set")
-            raise ValueError(
-                f"All bulk_update() objects must have a primary key set. "
-                f"{missing_pk_count} out of {len(objs)} objects are missing primary keys."
-            )
-
         # Remove custom hook kwargs and unsupported parameters before passing to Django internals
-        unsupported_params = ["unique_fields", "update_conflicts", "update_fields", "ignore_conflicts"]
+        unsupported_params = [
+            "unique_fields",
+            "update_conflicts",
+            "update_fields",
+            "ignore_conflicts",
+        ]
         django_kwargs = {}
         for k, v in kwargs.items():
             if k in unsupported_params:
@@ -1709,56 +1942,24 @@ class HookQuerySetMixin:
         if not objs:
             return 0
 
-        if any(not isinstance(obj, model_cls) for obj in objs):
-            raise TypeError(
-                f"bulk_delete expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
-            )
-
-        logger.debug(
-            f"bulk_delete {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}"
+        model_cls, ctx, _ = self._setup_bulk_operation(
+            objs, "bulk_delete", require_pks=True,
+            bypass_hooks=bypass_hooks, bypass_validation=bypass_validation
         )
 
-        # Fire hooks before DB ops
-        if not bypass_hooks:
-            ctx = HookContext(model_cls, bypass_hooks=False)
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
-            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
-        else:
-            ctx = HookContext(model_cls, bypass_hooks=True)
-            logger.debug("bulk_delete bypassed hooks")
-
-        # Before deletion, ensure all related fields are properly cached
-        # to avoid DoesNotExist errors in AFTER_DELETE hooks
-        if not bypass_hooks:
-            for obj in objs:
-                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
-                        ):
-                            try:
-                                # Access the related field to cache it before deletion
-                                getattr(obj, field.name)
-                            except Exception:
-                                # If we can't access the field (e.g., already deleted, no permission, etc.)
-                                # continue with other fields
-                                pass
-
-        # Use Django's standard delete() method on the queryset
-        pks = [obj.pk for obj in objs if obj.pk is not None]
-        if pks:
-            # Use the base manager to avoid recursion
-            result = self.model._base_manager.filter(pk__in=pks).delete()[0]
-        else:
-            result = 0
+        # Execute the database operation with hooks
+        def delete_operation():
+            pks = [obj.pk for obj in objs if obj.pk is not None]
+            if pks:
+                # Use the base manager to avoid recursion
+                return self.model._base_manager.filter(pk__in=pks).delete()[0]
+            else:
+                return 0
 
-        # Fire AFTER_DELETE hooks
-        if not bypass_hooks:
-            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
+        result = self._execute_delete_hooks_with_operation(
+            delete_operation, objs, ctx=ctx,
+            bypass_hooks=bypass_hooks, bypass_validation=bypass_validation
+        )
 
         return result
 

{django_bulk_hooks-0.1.266 → django_bulk_hooks-0.1.268}/pyproject.toml

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