django-bulk-hooks 0.1.122__tar.gz → 0.1.124__tar.gz

{django_bulk_hooks-0.1.122 → django_bulk_hooks-0.1.124}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.122
+Version: 0.1.124
 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.124/django_bulk_hooks/manager.py

@@ -0,0 +1,83 @@
+from django.db import models
+
+from django_bulk_hooks.queryset import HookQuerySet
+
+
+class BulkHookManager(models.Manager):
+    def get_queryset(self):
+        return HookQuerySet(self.model, using=self._db)
+
+    def bulk_update(
+        self, objs, fields, 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.
+        """
+        return self.get_queryset().bulk_update(
+            objs, fields, bypass_hooks=bypass_hooks, bypass_validation=bypass_validation, **kwargs
+        )
+
+    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,
+        )
+
+    def bulk_delete(
+        self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False
+    ):
+        """
+        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
+        )
+
+    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 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 save(self, obj):
+        """
+        Save a single object using the appropriate bulk operation.
+        """
+        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.122 → django_bulk_hooks-0.1.124}/django_bulk_hooks/queryset.py

@@ -1,10 +1,6 @@
-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.db import models, transaction
+from django.db.models import AutoField
 
 from django_bulk_hooks import engine
 from django_bulk_hooks.constants import (
@@ -303,8 +299,11 @@ class HookQuerySet(models.QuerySet):
         """
         Process a single batch of objects through the inheritance chain.
         """
-        # Step 1: Handle parent tables with individual saves (needed for PKs)
+        # Step 1: Handle parent tables with bulk operations where possible
         parent_objects_map = {}
+        
+        # Group parent objects by model class to enable bulk operations
+        parent_objects_by_model = {}
         for obj in batch:
             parent_instances = {}
             current_parent = None
@@ -312,10 +311,24 @@ class HookQuerySet(models.QuerySet):
                 parent_obj = self._create_parent_instance(
                     obj, model_class, current_parent
                 )
-                parent_obj.save()
                 parent_instances[model_class] = parent_obj
                 current_parent = parent_obj
+                
+                # Group by model class for potential bulk operations
+                if model_class not in parent_objects_by_model:
+                    parent_objects_by_model[model_class] = []
+                parent_objects_by_model[model_class].append(parent_obj)
+            
             parent_objects_map[id(obj)] = parent_instances
+        
+        # Save parent objects in bulk where possible
+        for model_class, parent_objs in parent_objects_by_model.items():
+            if len(parent_objs) > 1:
+                # Use bulk_create for multiple objects of the same model
+                model_class._base_manager.bulk_create(parent_objs)
+            else:
+                # Individual save for single objects
+                super(parent_objs[0].__class__, parent_objs[0]).save()
         # Step 2: Bulk insert for child objects
         child_model = inheritance_chain[-1]
         child_objects = []
@@ -324,22 +337,8 @@ class HookQuerySet(models.QuerySet):
                 obj, child_model, parent_objects_map.get(id(obj), {})
             )
             child_objects.append(child_obj)
-        # If the child model is still MTI, call our own logic recursively
+        # If the child model is still MTI, we need to handle it specially
         if len([p for p in child_model._meta.parents.keys() if not p._meta.proxy]) > 0:
-            # Build inheritance chain for the child model
-            child_inheritance_chain = []
-            current_model = child_model
-            while current_model:
-                if not current_model._meta.proxy:
-                    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
-            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.
@@ -388,6 +387,12 @@ class HookQuerySet(models.QuerySet):
             elif hasattr(field, 'auto_now') and field.auto_now:
                 field.pre_save(parent_obj, add=True)
         
+        # Ensure auto_now_add fields are explicitly set to prevent null constraint violations
+        for field in parent_model._meta.local_fields:
+            if hasattr(field, 'auto_now_add') and field.auto_now_add:
+                if getattr(parent_obj, field.name) is None:
+                    field.pre_save(parent_obj, add=True)
+        
         return parent_obj
 
     def _create_child_instance(self, source_obj, child_model, parent_instances):
@@ -411,4 +416,10 @@ class HookQuerySet(models.QuerySet):
             elif hasattr(field, 'auto_now') and field.auto_now:
                 field.pre_save(child_obj, add=True)
         
+        # Ensure auto_now_add fields are explicitly set to prevent null constraint violations
+        for field in child_model._meta.local_fields:
+            if hasattr(field, 'auto_now_add') and field.auto_now_add:
+                if getattr(child_obj, field.name) is None:
+                    field.pre_save(child_obj, add=True)
+        
         return child_obj

{django_bulk_hooks-0.1.122 → django_bulk_hooks-0.1.124}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.122"
+version = "0.1.124"
 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.122/django_bulk_hooks/manager.py

@@ -1,201 +0,0 @@
-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