django-bulk-hooks 0.2.9__py3-none-any.whl → 0.2.93__py3-none-any.whl

django_bulk_hooks/manager.py

@@ -1,130 +1,134 @@
-from django.db import models
-
-from django_bulk_hooks.queryset import HookQuerySet
-
-
-class BulkHookManager(models.Manager):
-    """
-    Manager that provides hook-aware bulk operations.
-
-    This is a simple facade that returns HookQuerySet,
-    delegating all bulk operations to it.
-    """
-
-    def get_queryset(self):
-        """
-        Return a HookQuerySet for this manager.
-
-        This ensures all bulk operations go through the coordinator.
-        """
-        base_queryset = super().get_queryset()
-
-        # If the base queryset is already a HookQuerySet, return it as-is
-        if isinstance(base_queryset, HookQuerySet):
-            return base_queryset
-
-        # Otherwise, create a new HookQuerySet with the same parameters
-        return HookQuerySet(
-            model=base_queryset.model,
-            query=base_queryset.query,
-            using=base_queryset._db,
-            hints=base_queryset._hints,
-        )
-
-    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,
-        )
-
-    def bulk_update(
-        self,
-        objs,
-        fields=None,
-        bypass_hooks=False,
-        bypass_validation=False,
-        **kwargs,
-    ):
-        """
-        Delegate to QuerySet's bulk_update implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-
-        Note: Parameters like unique_fields, update_conflicts, update_fields, and ignore_conflicts
-        are not supported by bulk_update and will be ignored with a warning.
-        These parameters are only available in bulk_create for UPSERT operations.
-        """
-        if fields is not None:
-            kwargs["fields"] = fields
-        return self.get_queryset().bulk_update(
-            objs,
-            bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
-            **kwargs,
-        )
-
-    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 delete(self):
-        """
-        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):
-        """
-        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):
-        """
-        Save a single object using the appropriate bulk operation.
-        """
-        if obj.pk:
-            # bulk_update now auto-detects changed fields
-            self.bulk_update([obj])
-        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,76 +1,89 @@
-import logging
-
-from django.db import models
-
-from django_bulk_hooks.manager import BulkHookManager
-
-logger = logging.getLogger(__name__)
-
-
-class HookModelMixin(models.Model):
-    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
-
-        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
-        else:
-            # 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"
-                ]
-            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()
+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

@@ -5,14 +5,14 @@ This module contains all services for bulk operations following
 a clean, service-based architecture.
 """
 
-from django_bulk_hooks.operations.coordinator import BulkOperationCoordinator
 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__ = [
-    'BulkOperationCoordinator',
-    'ModelAnalyzer',
-    'BulkExecutor',
-    'MTIHandler',
+    "BulkExecutor",
+    "BulkOperationCoordinator",
+    "MTIHandler",
+    "ModelAnalyzer",
 ]