django-bulk-hooks 0.1.121__py3-none-any.whl → 0.1.123__py3-none-any.whl

django_bulk_hooks/manager.py

@@ -1,77 +1,23 @@
-from django.db import models, transaction
+from django.db import models
 
-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
+        """
+        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
+        )
 
-    @transaction.atomic
     def bulk_create(
         self,
         objs,
@@ -98,62 +44,35 @@ class BulkHookManager(models.Manager):
             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
+        """
+        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, batch_size=batch_size, bypass_hooks=bypass_hooks, bypass_validation=bypass_validation
+        )
 
-    @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)
+        """
+        Delegate to QuerySet's update implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return self.get_queryset().update(**kwargs)
 
-    @transaction.atomic
     def delete(self):
-        objs = list(self.all())
-        if not objs:
-            return 0
-        self.bulk_delete(objs)
-        return len(objs)
+        """
+        Delegate to QuerySet's delete implementation.
+        This follows Django's pattern where Manager methods call QuerySet methods.
+        """
+        return self.get_queryset().delete()
 
-    @transaction.atomic
     def save(self, obj):
+        """
+        Save a single object using the appropriate bulk operation.
+        """
         if obj.pk:
             self.bulk_update(
                 [obj],
@@ -162,40 +81,3 @@ class BulkHookManager(models.Manager):
         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/queryset.py

@@ -284,6 +284,10 @@ class HookQuerySet(models.QuerySet):
         if inheritance_chain is None:
             inheritance_chain = self._get_inheritance_chain()
             
+        # Safety check to prevent infinite recursion
+        if len(inheritance_chain) > 10:  # Arbitrary limit to prevent infinite loops
+            raise ValueError("Inheritance chain too deep - possible infinite recursion detected")
+            
         batch_size = kwargs.get("batch_size") or len(objs)
         created_objects = []
         with transaction.atomic(using=self.db, savepoint=False):
@@ -323,19 +327,28 @@ class HookQuerySet(models.QuerySet):
         # If the child model is still MTI, call our own logic recursively
         if len([p for p in child_model._meta.parents.keys() if not p._meta.proxy]) > 0:
             # Build inheritance chain for the child model
-            inheritance_chain = []
+            child_inheritance_chain = []
             current_model = child_model
             while current_model:
                 if not current_model._meta.proxy:
-                    inheritance_chain.append(current_model)
+                    child_inheritance_chain.append(current_model)
                 parents = [
                     parent
                     for parent in current_model._meta.parents.keys()
                     if not parent._meta.proxy
                 ]
                 current_model = parents[0] if parents else None
-            inheritance_chain.reverse()
-            created = self._mti_bulk_create(child_objects, inheritance_chain, **kwargs)
+            child_inheritance_chain.reverse()
+            
+            # For nested MTI, we can't use bulk operations recursively
+            # because it would create infinite recursion. Instead, we save each child individually.
+            # We use super().save() to avoid triggering hooks that would cause recursion.
+            created = []
+            for child_obj in child_objects:
+                # Use the base model's save method to avoid triggering hooks
+                # This prevents infinite recursion when hooks try to query the database
+                super(child_obj.__class__, child_obj).save()
+                created.append(child_obj)
         else:
             # Single-table, safe to use bulk_create
             

{django_bulk_hooks-0.1.121.dist-info → django_bulk_hooks-0.1.123.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.121
+Version: 0.1.123
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.1.121.dist-info → django_bulk_hooks-0.1.123.dist-info}/RECORD

@@ -6,12 +6,12 @@ django_bulk_hooks/decorators.py,sha256=tckDcxtOzKCbgvS9QydgeIAWTFDEl-ch3_Q--ruEG
 django_bulk_hooks/engine.py,sha256=3HbgV12JRYIy9IlygHPxZiHnFXj7EwzLyTuJNQeVIoI,1402
 django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
 django_bulk_hooks/handler.py,sha256=xZt8iNdYF-ACz-MnKMY0co6scWINU5V5wC1lyDn844k,4854
-django_bulk_hooks/manager.py,sha256=DjEW-nZjhlBW6cp8GRPl6xOSsAmmquP0Y-QyCZMoSHo,6946
+django_bulk_hooks/manager.py,sha256=r54ct3S6AcqME2OsX-jPF944CEKcoSIW3qiAx_NwUaw,2801
 django_bulk_hooks/models.py,sha256=7RG7GrOdHXFjGVPV4FPRZVNMIHHW-hMCi6hn9LH_hVI,3331
 django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
-django_bulk_hooks/queryset.py,sha256=GPjyhzko8CsZoqj85oqzXjbRMSUaIn7xi6_OdJfyjm4,15914
+django_bulk_hooks/queryset.py,sha256=19uG70BxNAJwLqu3j3ZmT4DStX8sPRwbV9079m0yn84,16717
 django_bulk_hooks/registry.py,sha256=-mQBizJ06nz_tajZBinViKx_uP2Tbc1tIpTEMv7lwKA,705
-django_bulk_hooks-0.1.121.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.121.dist-info/METADATA,sha256=4_kx2vZEonPYANDAA0PDupUr4r9-QHz63224XPu6t0o,6951
-django_bulk_hooks-0.1.121.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.1.121.dist-info/RECORD,,
+django_bulk_hooks-0.1.123.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.123.dist-info/METADATA,sha256=1irToq1BSI9i4dP80sqHhRDq3BhwGVcEK0B-Xf69xXo,6951
+django_bulk_hooks-0.1.123.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.1.123.dist-info/RECORD,,