django-bulk-hooks 0.2.61__py3-none-any.whl → 0.2.63__py3-none-any.whl

django_bulk_hooks/manager.py

@@ -1,150 +1,150 @@
-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 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 _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,
-            bypass_validation=bypass_validation,
-            **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 _delegate_to_queryset(
-            self,
-            "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 _delegate_to_queryset(
-            self,
-            "bulk_delete",
-            objs,
-            batch_size=batch_size,
-            bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
-            **kwargs,
-        )
-
-    def delete(self):
-        """
-        Delegate to QuerySet's delete implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return _delegate_to_queryset(self, "delete")
-
-    def update(self, **kwargs):
-        """
-        Delegate to QuerySet's update implementation.
-        This follows Django's pattern where Manager methods call QuerySet methods.
-        """
-        return _delegate_to_queryset(self, "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 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 _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,
+            bypass_validation=bypass_validation,
+            **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 _delegate_to_queryset(
+            self,
+            "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 _delegate_to_queryset(
+            self,
+            "bulk_delete",
+            objs,
+            batch_size=batch_size,
+            bypass_hooks=bypass_hooks,
+            bypass_validation=bypass_validation,
+            **kwargs,
+        )
+
+    def delete(self):
+        """
+        Delegate to QuerySet's delete implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return _delegate_to_queryset(self, "delete")
+
+    def update(self, **kwargs):
+        """
+        Delegate to QuerySet's update implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return _delegate_to_queryset(self, "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

django_bulk_hooks/models.py

@@ -1,87 +1,74 @@
-import logging
-
-from django.db import models
-
-from django_bulk_hooks.manager import BulkHookManager
-
-logger = logging.getLogger(__name__)
-
-
-class TimestampMixin(models.Model):
-    """Mixin providing standard created_at and updated_at timestamp fields."""
-
-    created_at = models.DateTimeField(auto_now_add=True, help_text="When this record was created")
-    updated_at = models.DateTimeField(auto_now=True, help_text="When this record was last updated")
-
-    class Meta:
-        abstract = True
-
-
-class HookModelMixin(TimestampMixin, models.Model):
-    """Combined mixin providing timestamps and 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
-
-        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"
-            ]
-        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
+
+        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"]
+        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()