django-bulk-hooks 0.1.117__tar.gz → 0.1.119__tar.gz

{django_bulk_hooks-0.1.117 → django_bulk_hooks-0.1.119}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.117
+Version: 0.1.119
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
-Home-page: https://github.com/AugendLimited/django-bulk-hooks
 License: MIT
 Keywords: django,bulk,hooks
 Author: Konrad Beck
@@ -14,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Django (>=4.0)
+Project-URL: Homepage, https://github.com/AugendLimited/django-bulk-hooks
 Project-URL: Repository, https://github.com/AugendLimited/django-bulk-hooks
 Description-Content-Type: text/markdown
 

django_bulk_hooks-0.1.119/django_bulk_hooks/manager.py

@@ -0,0 +1,201 @@
+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 and ensure they match the order of new instances
+            original_map = {
+                obj.pk: obj
+                for obj in model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
+            }
+            originals = [original_map.get(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
+
+    @transaction.atomic
+    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,
+    ):
+        """
+        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,
+            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,
+        )
+
+    @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
+
+    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()
+
+        modified_fields = set()
+
+        # Since original_instances is now ordered to match new_instances, we can zip them directly
+        for new_instance, original in zip(new_instances, original_instances):
+            if new_instance.pk is None or original is None:
+                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

django_bulk_hooks-0.1.117/django_bulk_hooks/manager.py → django_bulk_hooks-0.1.119/django_bulk_hooks/queryset.py

@@ -1,5 +1,10 @@
-from django.db import models, transaction
-from django.db.models import AutoField
+from django.db import models, transaction, connections
+from django.db.models import AutoField, Q, Max
+from django.db import NotSupportedError
+from django.db.models.constants import OnConflict
+from django.db.models.expressions import DatabaseDefault
+import operator
+from functools import reduce
 
 from django_bulk_hooks import engine
 from django_bulk_hooks.constants import (
@@ -14,63 +19,48 @@ from django_bulk_hooks.constants import (
     VALIDATE_UPDATE,
 )
 from django_bulk_hooks.context import HookContext
-from django_bulk_hooks.queryset import HookQuerySet
 
 
-class BulkHookManager(models.Manager):
+class HookQuerySet(models.QuerySet):
     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
-    ):
+    def delete(self):
+        objs = list(self)
         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)}"
-            )
+            return 0
+        return self.model.objects.bulk_delete(objs)
 
-        if not bypass_hooks:
-            # Load originals for hook comparison and ensure they match the order of new instances
-            original_map = {
-                obj.pk: obj
-                for obj in model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
-            }
-            originals = [original_map.get(obj.pk) for obj in objs]
+    @transaction.atomic
+    def update(self, **kwargs):
+        instances = list(self)
+        if not instances:
+            return 0
 
-            ctx = HookContext(model_cls)
+        model_cls = self.model
+        pks = [obj.pk for obj in instances]
 
-            # Run validation hooks first
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_UPDATE, objs, originals, ctx=ctx)
+        # Load originals for hook comparison and ensure they match the order of instances
+        original_map = {obj.pk: obj for obj in model_cls.objects.filter(pk__in=pks)}
+        originals = [original_map.get(obj.pk) for obj in instances]
 
-            # Then run business logic hooks
-            engine.run(model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx)
+        # Apply field updates to instances
+        for obj in instances:
+            for field, value in kwargs.items():
+                setattr(obj, field, value)
 
-            # 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)
+        # Run BEFORE_UPDATE hooks
+        ctx = HookContext(model_cls)
+        engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
-        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)
+        # Use Django's built-in update logic directly
+        queryset = self.model.objects.filter(pk__in=pks)
+        update_count = queryset.update(**kwargs)
 
-        if not bypass_hooks:
-            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
+        # Run AFTER_UPDATE hooks
+        engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
 
-        return objs
+        return update_count
 
     @transaction.atomic
     def bulk_create(
@@ -86,7 +76,7 @@ class BulkHookManager(models.Manager):
     ):
         """
         Insert each of the instances into the database. Behaves like Django's bulk_create,
-        but supports multi-table inheritance (MTI) models. All arguments are supported and
+        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
@@ -94,10 +84,11 @@ class BulkHookManager(models.Manager):
         if batch_size is not None and batch_size <= 0:
             raise ValueError("Batch size must be a positive integer.")
 
-        # Check that the parents share the same concrete model with our model to detect inheritance pattern
+        # Check for MTI - if we detect multi-table inheritance, we need special handling
+        is_mti = False
         for parent in model_cls._meta.all_parents:
             if parent._meta.concrete_model is not model_cls._meta.concrete_model:
-                # We allow this for MTI, but not for single-table
+                is_mti = True
                 break
 
         if not objs:
@@ -108,9 +99,6 @@ class BulkHookManager(models.Manager):
                 f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        # Set auto_now_add/auto_now fields before DB ops
-        self._set_auto_now_fields(objs, model_cls)
-
         # Fire hooks before DB ops
         if not bypass_hooks:
             ctx = HookContext(model_cls)
@@ -118,12 +106,10 @@ class BulkHookManager(models.Manager):
                 engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
 
-        # MTI detection: if inheritance chain > 1, use MTI logic
-        inheritance_chain = self._get_inheritance_chain()
-        if len(inheritance_chain) <= 1:
-            # Single-table: use Django's standard bulk_create
-            # Pass through all supported arguments
-            result = super(models.Manager, self).bulk_create(
+        # For MTI models, we need to handle them specially
+        if is_mti:
+            # Use our MTI-specific logic
+            result = self._mti_bulk_create(
                 objs,
                 batch_size=batch_size,
                 ignore_conflicts=ignore_conflicts,
@@ -132,22 +118,105 @@ class BulkHookManager(models.Manager):
                 unique_fields=unique_fields,
             )
         else:
-            # Multi-table: use workaround (parent saves, child bulk)
-            # Only batch_size is supported for MTI; others will raise NotImplementedError
-            if ignore_conflicts or update_conflicts or update_fields or unique_fields:
-                raise NotImplementedError(
-                    "bulk_create with ignore_conflicts, update_conflicts, update_fields, or unique_fields is not supported for multi-table inheritance models."
-                )
-            result = self._mti_bulk_create(
-                objs, inheritance_chain, batch_size=batch_size
+            # For single-table models, use Django's built-in bulk_create
+            # but we need to call it on the base manager to avoid recursion
+            result = model_cls._base_manager.bulk_create(
+                objs,
+                batch_size=batch_size,
+                ignore_conflicts=ignore_conflicts,
+                update_conflicts=update_conflicts,
+                update_fields=update_fields,
+                unique_fields=unique_fields,
             )
 
         if not bypass_hooks:
-            engine.run(model_cls, AFTER_CREATE, result, ctx=ctx)
+            engine.run(model_cls, AFTER_CREATE, objs, ctx=ctx)
 
         return result
 
-    # --- Private helper methods (moved to bottom for clarity) ---
+    @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 and ensure they match the order of new instances
+            original_map = {
+                obj.pk: obj
+                for obj in model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
+            }
+            originals = [original_map.get(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().bulk_update(chunk, fields, **kwargs)
+
+        if not bypass_hooks:
+            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
+
+        return objs
+
+    @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
+
+    # --- Private helper methods ---
 
     def _detect_modified_fields(self, new_instances, original_instances):
         """
@@ -205,19 +274,19 @@ class BulkHookManager(models.Manager):
         chain.reverse()
         return chain
 
-    def _mti_bulk_create(self, objs, inheritance_chain, **kwargs):
+    def _mti_bulk_create(self, objs, inheritance_chain=None, **kwargs):
         """
         Implements workaround: individual saves for parents, bulk create for child.
         Sets auto_now_add/auto_now fields for each model in the chain.
         """
+        if inheritance_chain is None:
+            inheritance_chain = self._get_inheritance_chain()
+            
         batch_size = kwargs.get("batch_size") or len(objs)
         created_objects = []
         with transaction.atomic(using=self.db, savepoint=False):
             for i in range(0, len(objs), batch_size):
                 batch = objs[i : i + batch_size]
-                # Set auto_now fields for each model in the chain
-                for model in inheritance_chain:
-                    self._set_auto_now_fields(batch, model)
                 batch_result = self._process_mti_batch(
                     batch, inheritance_chain, **kwargs
                 )
@@ -311,85 +380,3 @@ class BulkHookManager(models.Manager):
             if parent_link:
                 setattr(child_obj, parent_link.name, parent_instance)
         return child_obj
-
-    def _set_auto_now_fields(self, objs, model):
-        """
-        Set auto_now_add and auto_now fields on objects before bulk_create.
-        """
-        from django.utils import timezone
-
-        now = timezone.now()
-        for obj in objs:
-            for field in model._meta.local_fields:
-                if (
-                    getattr(field, "auto_now_add", False)
-                    and getattr(obj, field.name, None) is None
-                ):
-                    setattr(obj, field.name, now)
-                if getattr(field, "auto_now", False):
-                    setattr(obj, field.name, now)
-
-    @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

{django_bulk_hooks-0.1.117 → django_bulk_hooks-0.1.119}/pyproject.toml

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

django_bulk_hooks-0.1.117/django_bulk_hooks/queryset.py

@@ -1,44 +0,0 @@
-from django.db import models, transaction
-
-
-class HookQuerySet(models.QuerySet):
-    @transaction.atomic
-    def delete(self):
-        objs = list(self)
-        if not objs:
-            return 0
-        return self.model.objects.bulk_delete(objs)
-
-    @transaction.atomic
-    def update(self, **kwargs):
-        instances = list(self)
-        if not instances:
-            return 0
-
-        model_cls = self.model
-        pks = [obj.pk for obj in instances]
-
-        # Load originals for hook comparison and ensure they match the order of instances
-        original_map = {obj.pk: obj for obj in model_cls.objects.filter(pk__in=pks)}
-        originals = [original_map.get(obj.pk) for obj in instances]
-
-        # Apply field updates to instances
-        for obj in instances:
-            for field, value in kwargs.items():
-                setattr(obj, field, value)
-
-        # Run BEFORE_UPDATE hooks
-        from django_bulk_hooks import engine
-        from django_bulk_hooks.context import HookContext
-
-        ctx = HookContext(model_cls)
-        engine.run(model_cls, "before_update", instances, originals, ctx=ctx)
-
-        # Use Django's built-in update logic directly
-        queryset = self.model.objects.filter(pk__in=pks)
-        update_count = queryset.update(**kwargs)
-
-        # Run AFTER_UPDATE hooks
-        engine.run(model_cls, "after_update", instances, originals, ctx=ctx)
-
-        return update_count