django-bulk-hooks 0.1.267__tar.gz → 0.1.269__tar.gz

{django_bulk_hooks-0.1.267 → django_bulk_hooks-0.1.269}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.267
+Version: 0.1.269
 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.267 → django_bulk_hooks-0.1.269}/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
@@ -555,6 +535,9 @@ class HookQuerySetMixin:
                     for field_name in unique_fields:
                         if hasattr(obj, field_name):
                             unique_value[field_name] = getattr(obj, field_name)
+                        elif hasattr(obj, field_name + '_id'):
+                            # Handle ForeignKey fields where _id suffix is used
+                            unique_value[field_name] = getattr(obj, field_name + '_id')
                     if unique_value:
                         unique_values.append(unique_value)
 
@@ -583,6 +566,9 @@ class HookQuerySetMixin:
                         for field_name in unique_fields:
                             if hasattr(obj, field_name):
                                 obj_unique_value[field_name] = getattr(obj, field_name)
+                            elif hasattr(obj, field_name + '_id'):
+                                # Handle ForeignKey fields where _id suffix is used
+                                obj_unique_value[field_name] = getattr(obj, field_name + '_id')
 
                         # Check if this record already exists using our bulk lookup
                         if obj_unique_value:
@@ -604,13 +590,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 +717,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
@@ -978,11 +951,11 @@ class HookQuerySetMixin:
         if not objs:
             return []
 
-        self._validate_objects(objs)
+        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)
+        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
@@ -1128,10 +1101,14 @@ class HookQuerySetMixin:
         logger.debug("Built value_map for %d objects", len(value_map))
         return value_map
 
-    def _validate_objects(self, objs):
+    def _validate_objects(self, objs, require_pks=False, operation_name="bulk_update"):
         """
-        Validate that all objects are instances of this queryset's model
-        and that they have primary keys (cannot bulk update unsaved objects).
+        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
 
@@ -1141,27 +1118,34 @@ class HookQuerySetMixin:
         }
         if invalid_types:
             raise TypeError(
-                f"bulk_update expected instances of {model_cls.__name__}, "
+                f"{operation_name} expected instances of {model_cls.__name__}, "
                 f"but got {invalid_types}"
             )
 
-        # Primary key check
-        missing_pks = [obj for obj in objs if obj.pk is None]
-        if missing_pks:
-            raise ValueError(
-                f"bulk_update cannot operate on unsaved {model_cls.__name__} instances. "
-                f"{len(missing_pks)} object(s) have no primary key."
-            )
+        # 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(
-            "Validated %d %s objects for bulk_update",
+            "Validated %d %s objects for %s",
             len(objs),
             model_cls.__name__,
+            operation_name,
         )
 
-    def _init_hook_context(self, bypass_hooks: bool, objs):
+    def _init_hook_context(self, bypass_hooks: bool, objs, operation_name="bulk_update"):
         """
-        Initialize the hook context for bulk_update.
+        Initialize the hook context for bulk operations.
+
+        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
@@ -1171,10 +1155,10 @@ class HookQuerySetMixin:
         model_cls = self.model
 
         if bypass_hooks:
-            logger.debug("bulk_update: hooks bypassed for %s", model_cls.__name__)
+            logger.debug("%s: hooks bypassed for %s", operation_name, model_cls.__name__)
             ctx = HookContext(model_cls, bypass_hooks=True)
         else:
-            logger.debug("bulk_update: hooks enabled for %s", model_cls.__name__)
+            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.
@@ -1234,13 +1218,14 @@ class HookQuerySetMixin:
 
         return fields_set, auto_now_fields, custom_update_fields
 
-    def _apply_auto_now_fields(self, objs, auto_now_fields):
+    def _apply_auto_now_fields(self, objs, auto_now_fields, add=False):
         """
         Apply the current timestamp to all auto_now fields on each object.
 
         Args:
-            objs (list[Model]): The model instances being updated.
+            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
@@ -1250,16 +1235,186 @@ class HookQuerySetMixin:
         current_time = timezone.now()
 
         logger.debug(
-            "Setting auto_now fields %s to %s for %d objects",
+            "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 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:
+            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).
@@ -1271,7 +1426,7 @@ class HookQuerySetMixin:
                 logger.debug(
                     "%s detected as MTI model (parent: %s)",
                     model_cls.__name__,
-                    parent.__name__,
+                    getattr(parent, "__name__", str(parent)),
                 )
                 return True
 
@@ -1793,56 +1948,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.267 → django_bulk_hooks-0.1.269}/pyproject.toml

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