django-bulk-hooks 0.1.111__tar.gz → 0.1.113__tar.gz

{django_bulk_hooks-0.1.111 → django_bulk_hooks-0.1.113}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.111
+Version: 0.1.113
 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
@@ -13,7 +14,6 @@ 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
 
@@ -48,7 +48,7 @@ from django_bulk_hooks.models import HookModelMixin
 
 class Account(HookModelMixin):
     balance = models.DecimalField(max_digits=10, decimal_places=2)
-    # The HookModelMixin automatically provides BulkHookManager
+    # The HookModelMixin automatically provides BulkManager
 ```
 
 ### Create a Hook Handler
@@ -204,10 +204,10 @@ LoanAccount.objects.bulk_update(reordered, ['balance'])
 
 ## 🧩 Integration with Queryable Properties
 
-You can extend from `BulkHookManager` to support formula fields or property querying.
+You can extend from `BulkManager` to support formula fields or property querying.
 
 ```python
-class MyManager(BulkHookManager, QueryablePropertiesManager):
+class MyManager(BulkManager, QueryablePropertiesManager):
     pass
 ```
 

{django_bulk_hooks-0.1.111 → django_bulk_hooks-0.1.113}/README.md

@@ -29,7 +29,7 @@ from django_bulk_hooks.models import HookModelMixin
 
 class Account(HookModelMixin):
     balance = models.DecimalField(max_digits=10, decimal_places=2)
-    # The HookModelMixin automatically provides BulkHookManager
+    # The HookModelMixin automatically provides BulkManager
 ```
 
 ### Create a Hook Handler
@@ -185,10 +185,10 @@ LoanAccount.objects.bulk_update(reordered, ['balance'])
 
 ## 🧩 Integration with Queryable Properties
 
-You can extend from `BulkHookManager` to support formula fields or property querying.
+You can extend from `BulkManager` to support formula fields or property querying.
 
 ```python
-class MyManager(BulkHookManager, QueryablePropertiesManager):
+class MyManager(BulkManager, QueryablePropertiesManager):
     pass
 ```
 

{django_bulk_hooks-0.1.111 → django_bulk_hooks-0.1.113}/django_bulk_hooks/manager.py

@@ -1,4 +1,5 @@
 from django.db import models, transaction
+from django.db.models import AutoField
 
 from django_bulk_hooks import engine
 from django_bulk_hooks.constants import (
@@ -39,7 +40,8 @@ class BulkHookManager(models.Manager):
         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])
+                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]
 
@@ -109,34 +111,150 @@ class BulkHookManager(models.Manager):
 
     @transaction.atomic
     def bulk_create(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
+        """
+        Enhanced bulk_create that handles multi-table inheritance (MTI) and single-table models.
+        Falls back to Django's standard bulk_create for single-table models.
+        Fires hooks as usual.
+        """
         model_cls = self.model
 
+        if not objs:
+            return []
+
         if any(not isinstance(obj, model_cls) for obj in objs):
             raise TypeError(
                 f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        result = []
-
+        # Fire hooks before DB ops
         if not bypass_hooks:
             ctx = HookContext(model_cls)
-
-            # Run validation hooks first
             if not bypass_validation:
                 engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
-
-            # Then run business logic hooks
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
 
-        for i in range(0, len(objs), self.CHUNK_SIZE):
-            chunk = objs[i : i + self.CHUNK_SIZE]
-            result.extend(super(models.Manager, self).bulk_create(chunk, **kwargs))
+        # 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
+            result = []
+            for i in range(0, len(objs), self.CHUNK_SIZE):
+                chunk = objs[i : i + self.CHUNK_SIZE]
+                result.extend(super(models.Manager, self).bulk_create(chunk, **kwargs))
+        else:
+            # Multi-table: use workaround (parent saves, child bulk)
+            result = self._mti_bulk_create(objs, inheritance_chain, **kwargs)
 
         if not bypass_hooks:
             engine.run(model_cls, AFTER_CREATE, result, ctx=ctx)
 
         return result
 
+    def _get_inheritance_chain(self):
+        """
+        Get the complete inheritance chain from root parent to current model.
+        Returns list of model classes in order: [RootParent, Parent, Child]
+        """
+        chain = []
+        current_model = self.model
+        while current_model:
+            if not current_model._meta.proxy:
+                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
+        chain.reverse()
+        return chain
+
+    def _mti_bulk_create(self, objs, inheritance_chain, **kwargs):
+        """
+        Implements workaround: individual saves for parents, bulk create for child.
+        """
+        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]
+                batch_result = self._process_mti_batch(
+                    batch, inheritance_chain, **kwargs
+                )
+                created_objects.extend(batch_result)
+        return created_objects
+
+    def _process_mti_batch(self, batch, inheritance_chain, **kwargs):
+        """
+        Process a single batch of objects through the inheritance chain.
+        """
+        # Step 1: Handle parent tables with individual saves (needed for PKs)
+        parent_objects_map = {}
+        for obj in batch:
+            parent_instances = {}
+            current_parent = None
+            for model_class in inheritance_chain[:-1]:
+                parent_obj = self._create_parent_instance(
+                    obj, model_class, current_parent
+                )
+                parent_obj.save()
+                parent_instances[model_class] = parent_obj
+                current_parent = parent_obj
+            parent_objects_map[id(obj)] = parent_instances
+        # Step 2: Bulk insert for child objects
+        child_model = inheritance_chain[-1]
+        child_objects = []
+        for obj in batch:
+            child_obj = self._create_child_instance(
+                obj, child_model, parent_objects_map.get(id(obj), {})
+            )
+            child_objects.append(child_obj)
+        # Use Django's _base_manager for child table to avoid recursion
+        child_manager = child_model._base_manager
+        child_manager._for_write = True
+        created = child_manager.bulk_create(child_objects, **kwargs)
+        # Step 3: Update original objects with generated PKs and state
+        pk_field_name = child_model._meta.pk.name
+        for orig_obj, child_obj in zip(batch, created):
+            setattr(orig_obj, pk_field_name, getattr(child_obj, pk_field_name))
+            orig_obj._state.adding = False
+            orig_obj._state.db = self.db
+        return batch
+
+    def _create_parent_instance(self, source_obj, parent_model, current_parent):
+        parent_obj = parent_model()
+        for field in parent_model._meta.local_fields:
+            # Only copy if the field exists on the source and is not None
+            if hasattr(source_obj, field.name):
+                value = getattr(source_obj, field.name, None)
+                if value is not None:
+                    setattr(parent_obj, field.name, value)
+        if current_parent is not None:
+            for field in parent_model._meta.local_fields:
+                if (
+                    hasattr(field, "remote_field")
+                    and field.remote_field
+                    and field.remote_field.model == current_parent.__class__
+                ):
+                    setattr(parent_obj, field.name, current_parent)
+                    break
+        return parent_obj
+
+    def _create_child_instance(self, source_obj, child_model, parent_instances):
+        child_obj = child_model()
+        for field in child_model._meta.local_fields:
+            if isinstance(field, AutoField):
+                continue
+            if hasattr(source_obj, field.name):
+                value = getattr(source_obj, field.name, None)
+                if value is not None:
+                    setattr(child_obj, field.name, value)
+        for parent_model, parent_instance in parent_instances.items():
+            parent_link = child_model._meta.get_ancestor_link(parent_model)
+            if parent_link:
+                setattr(child_obj, parent_link.name, parent_instance)
+        return child_obj
+
     @transaction.atomic
     def bulk_delete(
         self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False
@@ -162,7 +280,7 @@ class BulkHookManager(models.Manager):
             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()

{django_bulk_hooks-0.1.111 → django_bulk_hooks-0.1.113}/django_bulk_hooks/models.py

@@ -13,11 +13,11 @@ from django_bulk_hooks.constants import (
 )
 from django_bulk_hooks.context import HookContext
 from django_bulk_hooks.engine import run
-from django_bulk_hooks.manager import BulkHookManager
+from django_bulk_hooks.manager import BulkManager
 
 
 class HookModelMixin(models.Model):
-    objects = BulkHookManager()
+    objects = BulkManager()
 
     class Meta:
         abstract = True

{django_bulk_hooks-0.1.111 → django_bulk_hooks-0.1.113}/pyproject.toml

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