django-bulk-hooks 0.1.228__py3-none-any.whl → 0.1.229__py3-none-any.whl

django_bulk_hooks/manager.py

@@ -1,113 +1,135 @@
+from typing import Iterable, Sequence, Any
 from django.db import models
 
 from django_bulk_hooks.queryset import HookQuerySet, HookQuerySetMixin
 
 
 class BulkHookManager(models.Manager):
-    def get_queryset(self):
-        # 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
-        )
+	"""Manager that ensures all queryset operations are hook-aware.
 
-    def bulk_create(
-        self,
-        objs,
-        batch_size=None,
-        ignore_conflicts=False,
-        update_conflicts=False,
-        update_fields=None,
-        unique_fields=None,
-        bypass_hooks=False,
-        bypass_validation=False,
-        **kwargs,
-    ):
-        """
-        Delegate to QuerySet's bulk_create implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().bulk_create(
-            objs,
-            bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
-            batch_size=batch_size,
-            ignore_conflicts=ignore_conflicts,
-            update_conflicts=update_conflicts,
-            update_fields=update_fields,
-            unique_fields=unique_fields,
-            **kwargs,
-        )
+	Delegates operations to a hook-enabled queryset while preserving any
+	customizations from other managers in the MRO by starting with
+	``super().get_queryset()``.
+	"""
 
-    def bulk_update(
-        self, objs, fields, 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.
-        """
-        return self.get_queryset().bulk_update(
-            objs,
-            fields,
-            bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
-            **kwargs,
-        )
+	# Cache for composed queryset classes to preserve custom queryset APIs
+	_qs_compose_cache = {}
 
-    def bulk_delete(
-        self,
-        objs,
-        batch_size=None,
-        bypass_hooks=False,
-        bypass_validation=False,
-        **kwargs,
-    ):
-        """
-        Delegate to QuerySet's bulk_delete implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().bulk_delete(
-            objs,
-            bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
-            batch_size=batch_size,
-            **kwargs,
-        )
+	def get_queryset(self) -> HookQuerySet:
+		# Use super().get_queryset() to let Django and MRO build the queryset
+		base_queryset = super().get_queryset()
 
-    def delete(self):
-        """
-        Delegate to QuerySet's delete implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().delete()
+		# If the base queryset already has hook functionality, return it as-is
+		if isinstance(base_queryset, HookQuerySetMixin):
+			return base_queryset  # type: ignore[return-value]
 
-    def update(self, **kwargs):
-        """
-        Delegate to QuerySet's update implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return self.get_queryset().update(**kwargs)
+		# Otherwise, dynamically compose a queryset class that preserves the
+		# base queryset's custom API while adding hook behavior
+		base_cls = base_queryset.__class__
+		composed_cls = self._qs_compose_cache.get(base_cls)
+		if composed_cls is None:
+			composed_name = f"ComposedHookQuerySet_{base_cls.__name__}"
+			composed_cls = type(composed_name, (HookQuerySetMixin, base_cls), {})
+			self._qs_compose_cache[base_cls] = composed_cls
 
-    def save(self, obj):
-        """
-        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"],
-            )
-        else:
-            self.bulk_create([obj])
-        return obj
+		return composed_cls(
+			model=base_queryset.model,
+			query=base_queryset.query,
+			using=base_queryset._db,
+			hints=base_queryset._hints,
+		)
+
+	def bulk_create(
+		self,
+		objs: Iterable[models.Model],
+		batch_size: int | None = None,
+		ignore_conflicts: bool = False,
+		update_conflicts: bool = False,
+		update_fields: Sequence[str] | None = None,
+		unique_fields: Sequence[str] | None = None,
+		bypass_hooks: bool = False,
+		bypass_validation: bool = False,
+		**kwargs: Any,
+	) -> list[models.Model]:
+		"""
+		Delegate to QuerySet's bulk_create implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().bulk_create(
+			objs,
+			bypass_hooks=bypass_hooks,
+			bypass_validation=bypass_validation,
+			batch_size=batch_size,
+			ignore_conflicts=ignore_conflicts,
+			update_conflicts=update_conflicts,
+			update_fields=update_fields,
+			unique_fields=unique_fields,
+			**kwargs,
+		)
+
+	def bulk_update(
+		self,
+		objs: Iterable[models.Model],
+		fields: Sequence[str],
+		bypass_hooks: bool = False,
+		bypass_validation: bool = False,
+		**kwargs: Any,
+	) -> int:
+		"""
+		Delegate to QuerySet's bulk_update implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().bulk_update(
+			objs,
+			fields,
+			bypass_hooks=bypass_hooks,
+			bypass_validation=bypass_validation,
+			**kwargs,
+		)
+
+	def bulk_delete(
+		self,
+		objs: Iterable[models.Model],
+		batch_size: int | None = None,
+		bypass_hooks: bool = False,
+		bypass_validation: bool = False,
+		**kwargs: Any,
+	) -> int:
+		"""
+		Delegate to QuerySet's bulk_delete implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().bulk_delete(
+			objs,
+			bypass_hooks=bypass_hooks,
+			bypass_validation=bypass_validation,
+			batch_size=batch_size,
+			**kwargs,
+		)
+
+	def delete(self) -> int:
+		"""
+		Delegate to QuerySet's delete implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().delete()
+
+	def update(self, **kwargs: Any) -> int:
+		"""
+		Delegate to QuerySet's update implementation.
+		This follows Django's pattern where Manager methods call QuerySet methods.
+		"""
+		return self.get_queryset().update(**kwargs)
+
+	def save(self, obj: models.Model) -> models.Model:
+		"""
+		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"],
+			)
+		else:
+			self.bulk_create([obj])
+		return obj

django_bulk_hooks/models.py

@@ -1,6 +1,5 @@
 import logging
-from django.db import models
-
+from django.db import models, transaction
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -42,18 +41,18 @@ class HookModelMixin(models.Model):
 
         if is_create:
             # For create operations, run VALIDATE_CREATE hooks for validation
-            ctx = HookContext(self.__class__)
+            ctx = HookContext(self.__class__, bypass_hooks)
             run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
         else:
             # For update operations, run VALIDATE_UPDATE hooks for validation
             try:
                 # Use _base_manager to avoid triggering hooks recursively
                 old_instance = self.__class__._base_manager.get(pk=self.pk)
-                ctx = HookContext(self.__class__)
+                ctx = HookContext(self.__class__, bypass_hooks)
                 run(self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx)
             except self.__class__.DoesNotExist:
                 # If the old instance doesn't exist, treat as create
-                ctx = HookContext(self.__class__)
+                ctx = HookContext(self.__class__, bypass_hooks)
                 run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
 
     def save(self, *args, bypass_hooks=False, **kwargs):
@@ -62,12 +61,27 @@ class HookModelMixin(models.Model):
             logger.debug(f"save() called with bypass_hooks=True for {self.__class__.__name__} pk={self.pk}")
             return self._base_manager.save(self, *args, **kwargs)
 
-        is_create = self.pk is None
+        # Only create a new transaction if we're not already in one
+        # This allows for proper nested transaction handling
+        from django.db import connection
+        if connection.in_atomic_block:
+            # We're already in a transaction, don't create a new one
+            return self._save_with_hooks(*args, **kwargs)
+        else:
+            # We're not in a transaction, so create one
+            with transaction.atomic():
+                return self._save_with_hooks(*args, **kwargs)
 
+    def _save_with_hooks(self, *args, **kwargs):
+        """Internal method to handle save with hooks."""
+        is_create = self.pk is None
+        
         if is_create:
             logger.debug(f"save() creating new {self.__class__.__name__} instance")
             # For create operations, we don't have old records
-            ctx = HookContext(self.__class__)
+            ctx = HookContext(self.__class__, bypass_hooks=False)
+            
+            # Run hooks - if any fail, the transaction will be rolled back
             run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
             run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
 
@@ -80,7 +94,9 @@ class HookModelMixin(models.Model):
             try:
                 # Use _base_manager to avoid triggering hooks recursively
                 old_instance = self.__class__._base_manager.get(pk=self.pk)
-                ctx = HookContext(self.__class__)
+                ctx = HookContext(self.__class__, bypass_hooks=False)
+                
+                # Run hooks - if any fail, the transaction will be rolled back
                 run(self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx)
                 run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
 
@@ -89,7 +105,9 @@ class HookModelMixin(models.Model):
                 run(self.__class__, AFTER_UPDATE, [self], [old_instance], ctx=ctx)
             except self.__class__.DoesNotExist:
                 # If the old instance doesn't exist, treat as create
-                ctx = HookContext(self.__class__)
+                ctx = HookContext(self.__class__, bypass_hooks=False)
+                
+                # Run hooks - if any fail, the transaction will be rolled back
                 run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
                 run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
 
@@ -104,9 +122,22 @@ class HookModelMixin(models.Model):
         if bypass_hooks:
             return self._base_manager.delete(self, *args, **kwargs)
 
-        ctx = HookContext(self.__class__)
+        # Only create a new transaction if we're not already in one
+        # This allows for proper nested transaction handling
+        from django.db import connection
+        if connection.in_atomic_block:
+            # We're already in a transaction, don't create a new one
+            return self._delete_with_hooks(*args, **kwargs)
+        else:
+            # We're not in a transaction, so create one
+            with transaction.atomic():
+                return self._delete_with_hooks(*args, **kwargs)
+
+    def _delete_with_hooks(self, *args, **kwargs):
+        """Internal method to handle delete with hooks."""
+        ctx = HookContext(self.__class__, bypass_hooks=False)
 
-        # Run validation hooks first
+        # Run hooks - if any fail, the transaction will be rolled back
         run(self.__class__, VALIDATE_DELETE, [self], ctx=ctx)
 
         # Then run business logic hooks