django-bulk-hooks 0.1.83__py3-none-any.whl → 0.2.100__py3-none-any.whl

django_bulk_hooks/manager.py

@@ -1,208 +1,134 @@
-from django.db import models, transaction
-
-from django_bulk_hooks import engine
-from django_bulk_hooks.constants import (
-    AFTER_CREATE,
-    AFTER_DELETE,
-    AFTER_UPDATE,
-    BEFORE_CREATE,
-    BEFORE_DELETE,
-    BEFORE_UPDATE,
-    VALIDATE_CREATE,
-    VALIDATE_DELETE,
-    VALIDATE_UPDATE,
-)
-from django_bulk_hooks.context import HookContext
-from django_bulk_hooks.queryset import HookQuerySet
-
-
-class BulkHookManager(models.Manager):
-    CHUNK_SIZE = 200
-
-    def get_queryset(self):
-        return HookQuerySet(self.model, using=self._db)
-
-    @transaction.atomic
-    def bulk_update(
-        self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
-    ):
-        if not objs:
-            return []
-
-        model_cls = self.model
-
-        if any(not isinstance(obj, model_cls) for obj in objs):
-            raise TypeError(
-                f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
-            )
-
-        if not bypass_hooks:
-            # Load originals for hook comparison
-            originals = list(
-                model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
-            )
-
-            ctx = HookContext(model_cls)
-
-            # Run validation hooks first
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_UPDATE, objs, originals, ctx=ctx)
-
-            # Then run business logic hooks
-            engine.run(model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx)
-
-            # Automatically detect fields that were modified during BEFORE_UPDATE hooks
-            modified_fields = self._detect_modified_fields(objs, originals)
-            if modified_fields:
-                # Convert to set for efficient union operation
-                fields_set = set(fields)
-                fields_set.update(modified_fields)
-                fields = list(fields_set)
-
-        for i in range(0, len(objs), self.CHUNK_SIZE):
-            chunk = objs[i : i + self.CHUNK_SIZE]
-            # Call the base implementation to avoid re-triggering this method
-            super(models.Manager, self).bulk_update(chunk, fields, **kwargs)
-
-        if not bypass_hooks:
-            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
-
-        return objs
-
-    def _detect_modified_fields(self, new_instances, original_instances):
-        """
-        Detect fields that were modified during BEFORE_UPDATE hooks by comparing
-        new instances with their original values.
-        """
-        if not original_instances:
-            return set()
-
-        # Create a mapping of pk to original instance for efficient lookup
-        original_map = {obj.pk: obj for obj in original_instances if obj.pk is not None}
-
-        modified_fields = set()
-
-        for new_instance in new_instances:
-            if new_instance.pk is None:
-                continue
-
-            original = original_map.get(new_instance.pk)
-            if not original:
-                continue
-
-            # Compare all fields to detect changes
-            for field in new_instance._meta.fields:
-                if field.name == "id":
-                    continue
-
-                new_value = getattr(new_instance, field.name)
-                original_value = getattr(original, field.name)
-
-                # Handle different field types appropriately
-                if field.is_relation:
-                    # For foreign keys, compare the pk values
-                    new_pk = new_value.pk if new_value else None
-                    original_pk = original_value.pk if original_value else None
-                    if new_pk != original_pk:
-                        modified_fields.add(field.name)
-                else:
-                    # For regular fields, use direct comparison
-                    if new_value != original_value:
-                        modified_fields.add(field.name)
-
-        return modified_fields
-
-    @transaction.atomic
-    def bulk_create(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
-        model_cls = self.model
-
-        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)}"
-            )
-
-        result = []
-
-        if not bypass_hooks:
-            ctx = HookContext(model_cls)
-
-            # Run validation hooks first
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
-
-            # Then run business logic hooks
-            engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
-
-        for i in range(0, len(objs), self.CHUNK_SIZE):
-            chunk = objs[i : i + self.CHUNK_SIZE]
-            result.extend(super(models.Manager, self).bulk_create(chunk, **kwargs))
-
-        if not bypass_hooks:
-            engine.run(model_cls, AFTER_CREATE, result, ctx=ctx)
-
-        return result
-
-    @transaction.atomic
-    def bulk_delete(
-        self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False
-    ):
-        if not objs:
-            return []
-
-        model_cls = self.model
-
-        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)}"
-            )
-
-        ctx = HookContext(model_cls)
-
-        if not bypass_hooks:
-            # Run validation hooks first
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
-
-            # Then run business logic hooks
-            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
-
-        pks = [obj.pk for obj in objs if obj.pk is not None]
-        
-        # Use base manager for the actual deletion to prevent recursion
-        # The hooks have already been fired above, so we don't need them again
-        model_cls._base_manager.filter(pk__in=pks).delete()
-
-        if not bypass_hooks:
-            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
-
-        return objs
-
-    @transaction.atomic
-    def update(self, **kwargs):
-        objs = list(self.all())
-        if not objs:
-            return 0
-        for key, value in kwargs.items():
-            for obj in objs:
-                setattr(obj, key, value)
-        self.bulk_update(objs, fields=list(kwargs.keys()))
-        return len(objs)
-
-    @transaction.atomic
-    def delete(self):
-        objs = list(self.all())
-        if not objs:
-            return 0
-        self.bulk_delete(objs)
-        return len(objs)
-
-    @transaction.atomic
-    def save(self, obj):
-        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
+from django.db import models
+
+from django_bulk_hooks.queryset import HookQuerySet
+
+
+def _delegate_to_queryset(self, method_name, *args, **kwargs):
+    """
+    Generic delegation to queryset method.
+
+    Args:
+        method_name: Name of the method to call on the queryset
+        *args, **kwargs: Arguments to pass to the method
+
+    Returns:
+        Result of the queryset method call
+    """
+    return getattr(self.get_queryset(), method_name)(*args, **kwargs)
+
+
+class BulkHookManager(models.Manager):
+    """
+    Manager that provides hook-aware bulk operations.
+
+    This manager automatically applies hook functionality to its querysets.
+    It can be used as a base class or composed with other managers using
+    the queryset-based approach.
+    """
+
+    def get_queryset(self):
+        """
+        Return a HookQuerySet for this manager.
+
+        Uses the new with_hooks() method for better composition with other managers.
+        """
+        base_queryset = super().get_queryset()
+        return HookQuerySet.with_hooks(base_queryset)
+
+    def bulk_create(
+        self,
+        objs,
+        batch_size=None,
+        ignore_conflicts=False,
+        update_conflicts=False,
+        update_fields=None,
+        unique_fields=None,
+        bypass_hooks=False,
+        **kwargs,
+    ):
+        """
+        Delegate to QuerySet's bulk_create implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return _delegate_to_queryset(
+            self,
+            "bulk_create",
+            objs,
+            batch_size=batch_size,
+            ignore_conflicts=ignore_conflicts,
+            update_conflicts=update_conflicts,
+            update_fields=update_fields,
+            unique_fields=unique_fields,
+            bypass_hooks=bypass_hooks,
+            **kwargs,
+        )
+
+    def bulk_update(
+        self,
+        objs,
+        fields=None,
+        bypass_hooks=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.
+        """
+        if fields is not None:
+            kwargs["fields"] = fields
+        return _delegate_to_queryset(
+            self,
+            "bulk_update",
+            objs,
+            bypass_hooks=bypass_hooks,
+            **kwargs,
+        )
+
+    def bulk_delete(
+        self,
+        objs,
+        batch_size=None,
+        bypass_hooks=False,
+        **kwargs,
+    ):
+        """
+        Delegate to QuerySet's bulk_delete implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return _delegate_to_queryset(
+            self,
+            "bulk_delete",
+            objs,
+            batch_size=batch_size,
+            bypass_hooks=bypass_hooks,
+            **kwargs,
+        )
+
+    def delete(self, bypass_hooks=False):
+        """
+        Delegate to QuerySet's delete implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return _delegate_to_queryset(self, "delete", bypass_hooks=bypass_hooks)
+
+    def update(self, bypass_hooks=False, **kwargs):
+        """
+        Delegate to QuerySet's update implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return _delegate_to_queryset(self, "update", bypass_hooks=bypass_hooks, **kwargs)
+
+    def save(self, obj, bypass_hooks=False):
+        """
+        Save a single object using the appropriate bulk operation.
+        """
+        if obj.pk:
+            # bulk_update now auto-detects changed fields
+            self.bulk_update([obj], bypass_hooks=bypass_hooks)
+        else:
+            self.bulk_create([obj], bypass_hooks=bypass_hooks)
+        return obj

django_bulk_hooks/models.py

@@ -1,101 +1,89 @@
-from django.db import models, transaction
-
-from django_bulk_hooks.constants import (
-    AFTER_CREATE,
-    AFTER_DELETE,
-    AFTER_UPDATE,
-    BEFORE_CREATE,
-    BEFORE_DELETE,
-    BEFORE_UPDATE,
-    VALIDATE_CREATE,
-    VALIDATE_DELETE,
-    VALIDATE_UPDATE,
-)
-from django_bulk_hooks.context import HookContext
-from django_bulk_hooks.engine import run
-from django_bulk_hooks.manager import BulkHookManager
-
-
-class HookModelMixin(models.Model):
-    objects = BulkHookManager()
-
-    class Meta:
-        abstract = True
-
-    def clean(self):
-        """
-        Override clean() to trigger validation hooks.
-        This ensures that when Django calls clean() (like in admin forms),
-        it triggers the VALIDATE_* hooks for validation only.
-        """
-        # Call Django's clean first
-        super().clean()
-
-        # Skip hook validation during admin form validation
-        # This prevents RelatedObjectDoesNotExist errors when Django hasn't
-        # fully set up the object's relationships yet
-        if hasattr(self, '_state') and getattr(self._state, 'validating', False):
-            return
-
-        # Determine if this is a create or update operation
-        is_create = self.pk is None
-
-        if is_create:
-            # For create operations, run VALIDATE_CREATE hooks for validation
-            ctx = HookContext(self.__class__)
-            run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
-        else:
-            # For update operations, run VALIDATE_UPDATE hooks for validation
-            try:
-                old_instance = self.__class__.objects.get(pk=self.pk)
-                ctx = HookContext(self.__class__)
-                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__)
-                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
-
-    def save(self, *args, **kwargs):
-        is_create = self.pk is None
-        ctx = HookContext(self.__class__)
-
-        if is_create:
-            # For create operations, let Django save first so relationships are set up
-            super().save(*args, **kwargs)
-            
-            # Now run hooks after Django has set up the object
-            run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-            run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
-        else:
-            # For update operations, we need to get the old record
-            try:
-                old_instance = self.__class__.objects.get(pk=self.pk)
-                
-                # Let Django save first
-                super().save(*args, **kwargs)
-                
-                # Now run hooks after Django has set up the object
-                run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
-                run(self.__class__, AFTER_UPDATE, [self], [old_instance], ctx=ctx)
-            except self.__class__.DoesNotExist:
-                # If the old instance doesn't exist, treat as create
-                super().save(*args, **kwargs)
-                
-                run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-                run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
-
-        return self
-
-    def delete(self, *args, **kwargs):
-        ctx = HookContext(self.__class__)
-
-        # Run validation hooks first
-        run(self.__class__, VALIDATE_DELETE, [self], ctx=ctx)
-
-        # Then run business logic hooks
-        run(self.__class__, BEFORE_DELETE, [self], ctx=ctx)
-
-        result = super().delete(*args, **kwargs)
-
-        run(self.__class__, AFTER_DELETE, [self], ctx=ctx)
-        return result
+import logging
+
+from django.db import models
+
+from django_bulk_hooks.manager import BulkHookManager
+
+logger = logging.getLogger(__name__)
+
+
+class HookModelMixin(models.Model):
+    """Mixin providing hook functionality."""
+
+    objects = BulkHookManager()
+
+    class Meta:
+        abstract = True
+
+    def clean(self, bypass_hooks=False):
+        """
+        Override clean() to hook validation hooks.
+        This ensures that when Django calls clean() (like in admin forms),
+        it hooks the VALIDATE_* hooks for validation only.
+        """
+        super().clean()
+
+        # If bypass_hooks is True, skip validation hooks
+        if bypass_hooks:
+            return
+
+        # Delegate to coordinator (consistent with save/delete)
+        is_create = self.pk is None
+        self.__class__.objects.get_queryset().coordinator.clean(
+            [self],
+            is_create=is_create,
+        )
+
+    def save(self, *args, bypass_hooks=False, **kwargs):
+        """
+        Save the model instance.
+
+        Delegates to bulk_create/bulk_update which handle all hook logic
+        including MTI parent hooks.
+        """
+        if bypass_hooks:
+            # Use super().save() to call Django's default save without our hook logic
+            return super().save(*args, **kwargs)
+
+        is_create = self.pk is None
+
+        logger.debug("💾 SAVE_START: model=%s, pk=%s, is_create=%s, __dict__=%s",
+                    self.__class__.__name__, self.pk, is_create, list(self.__dict__.keys()))
+
+        if is_create:
+            # Delegate to bulk_create which handles all hook logic
+            result = self.__class__.objects.bulk_create([self])
+            return result[0] if result else self
+        # Delegate to bulk_update which handles all hook logic
+        update_fields = kwargs.get("update_fields")
+        if update_fields is None:
+            # Update all non-auto fields
+            update_fields = [f.name for f in self.__class__._meta.fields if not f.auto_created and f.name != "id"]
+
+        logger.debug("💾 SAVE_UPDATE_FIELDS: fields=%s (count=%d)", update_fields, len(update_fields))
+
+        # Log FK field values before bulk_update
+        for field in self.__class__._meta.fields:
+            if field.get_internal_type() == 'ForeignKey' and field.name in update_fields:
+                fk_id_value = getattr(self, field.attname, 'NO_ATTR')
+                fk_obj_value = getattr(self, field.name, 'NO_ATTR')
+                logger.debug("💾 SAVE_FK_CHECK: field=%s, %s=%s, %s=%s (has_pk=%s)",
+                            field.name, field.attname, fk_id_value, field.name, fk_obj_value,
+                            hasattr(fk_obj_value, 'pk') if fk_obj_value != 'NO_ATTR' else 'N/A')
+
+        self.__class__.objects.bulk_update([self], update_fields)
+        return self
+
+    def delete(self, *args, bypass_hooks=False, **kwargs):
+        """
+        Delete the model instance.
+
+        Delegates to bulk_delete which handles all hook logic
+        including MTI parent hooks.
+        """
+        if bypass_hooks:
+            # Use super().delete() to call Django's default delete without our hook logic
+            return super().delete(*args, **kwargs)
+
+        # Delegate to bulk_delete (handles both MTI and non-MTI)
+        return self.__class__.objects.filter(pk=self.pk).delete()

django_bulk_hooks/operations/__init__.py

@@ -0,0 +1,18 @@
+"""
+Operations module for django-bulk-hooks.
+
+This module contains all services for bulk operations following
+a clean, service-based architecture.
+"""
+
+from django_bulk_hooks.operations.analyzer import ModelAnalyzer
+from django_bulk_hooks.operations.bulk_executor import BulkExecutor
+from django_bulk_hooks.operations.coordinator import BulkOperationCoordinator
+from django_bulk_hooks.operations.mti_handler import MTIHandler
+
+__all__ = [
+    "BulkExecutor",
+    "BulkOperationCoordinator",
+    "MTIHandler",
+    "ModelAnalyzer",
+]