django-bulk-hooks 0.1.110__tar.gz → 0.1.112__tar.gz

{django_bulk_hooks-0.1.110 → django_bulk_hooks-0.1.112}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.110
+Version: 0.1.112
 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.110 → django_bulk_hooks-0.1.112}/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.112/django_bulk_hooks/__init__.py

@@ -0,0 +1,4 @@
+from django_bulk_hooks.handler import Hook
+from django_bulk_hooks.manager import BulkManager
+
+__all__ = ["BulkManager", "Hook"]

django_bulk_hooks-0.1.112/django_bulk_hooks/manager.py

@@ -0,0 +1,321 @@
+from django.db import models, transaction
+from django.db.models import AutoField
+
+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
+
+    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
+
+    @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)}"
+            )
+
+        # Fire hooks before DB ops
+        if not bypass_hooks:
+            ctx = HookContext(model_cls)
+            if not bypass_validation:
+                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
+            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
+    ):
+        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.110 → django_bulk_hooks-0.1.112}/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.110 → django_bulk_hooks-0.1.112}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.110"
+version = "0.1.112"
 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.110/django_bulk_hooks/__init__.py

@@ -1,4 +0,0 @@
-from django_bulk_hooks.handler import Hook
-from django_bulk_hooks.manager import BulkHookManager
-
-__all__ = ["BulkHookManager", "Hook"]

django_bulk_hooks-0.1.110/django_bulk_hooks/manager.py

@@ -1,394 +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)
-
-    def _has_multi_table_inheritance(self, model_cls):
-        """
-        Check if this model uses multi-table inheritance.
-        """
-        if not model_cls._meta.parents:
-            return False
-        
-        # Check if any parent is not abstract
-        for parent_model in model_cls._meta.parents.keys():
-            if not parent_model._meta.abstract:
-                return True
-        
-        return False
-    
-    def _get_base_model(self, model_cls):
-        """
-        Get the base model (first non-abstract parent or self).
-        """
-        base_model = model_cls
-        while base_model._meta.parents:
-            # Get the first non-abstract parent model
-            for parent_model in base_model._meta.parents.keys():
-                if not parent_model._meta.abstract:
-                    base_model = parent_model
-                    break
-            else:
-                # No non-abstract parents found, break the loop
-                break
-        return base_model
-    
-    def _extract_base_objects(self, objs, model_cls):
-        """
-        Extract base model objects from inherited objects.
-        """
-        base_model = self._get_base_model(model_cls)
-        base_objects = []
-        
-        for obj in objs:
-            base_obj = base_model()
-            for field in base_model._meta.fields:
-                # Skip ID field
-                if field.name == 'id':
-                    continue
-                
-                # Safely copy field values
-                try:
-                    if hasattr(obj, field.name):
-                        setattr(base_obj, field.name, getattr(obj, field.name))
-                except (AttributeError, ValueError):
-                    # Skip fields that can't be copied
-                    continue
-            
-            base_objects.append(base_obj)
-        
-        return base_objects
-    
-    def _extract_child_objects(self, objs, model_cls):
-        """
-        Extract child model objects from inherited objects.
-        """
-        child_objects = []
-        
-        for obj in objs:
-            child_obj = model_cls()
-            child_obj.pk = obj.pk  # Set the same PK as base
-            
-            # Copy only fields specific to this model
-            for field in model_cls._meta.fields:
-                # Skip ID field and fields that don't belong to this model
-                if field.name == 'id':
-                    continue
-                
-                # Check if this field belongs to the current model
-                # Use a safer way to check field ownership
-                try:
-                    if hasattr(field, 'model') and field.model == model_cls:
-                        # This field belongs to the current model
-                        if hasattr(obj, field.name):
-                            setattr(child_obj, field.name, getattr(obj, field.name))
-                except AttributeError:
-                    # Skip fields that don't have proper model reference
-                    continue
-            
-            child_objects.append(child_obj)
-        
-        return child_objects
-    
-    def _bulk_create_inherited(self, objs, **kwargs):
-        """
-        Handle bulk create for inherited models by handling each table separately.
-        """
-        if not objs:
-            return []
-        
-        model_cls = self.model
-        result = []
-        
-        # Group objects by their actual class
-        objects_by_class = {}
-        for obj in objs:
-            obj_class = obj.__class__
-            if obj_class not in objects_by_class:
-                objects_by_class[obj_class] = []
-            objects_by_class[obj_class].append(obj)
-        
-        for obj_class, class_objects in objects_by_class.items():
-            try:
-                # Check if this class has multi-table inheritance
-                parent_models = [p for p in obj_class._meta.get_parent_list() 
-                               if not p._meta.abstract]
-                
-                if not parent_models:
-                    # No inheritance, use standard bulk_create
-                    chunk_result = super(models.Manager, self).bulk_create(class_objects, **kwargs)
-                    result.extend(chunk_result)
-                    continue
-                
-                # Handle multi-table inheritance
-                # Step 1: Bulk create base objects with hooks
-                base_objects = self._extract_base_objects(class_objects, obj_class)
-                
-                # Use the model's manager with hooks
-                base_model = self._get_base_model(obj_class)
-                
-                # Try to avoid recursion by using raw SQL or _base_manager
-                try:
-                    if hasattr(base_model.objects, 'bulk_create'):
-                        # Use the base model's manager with hooks
-                        created_base = base_model.objects.bulk_create(base_objects, **kwargs)
-                    else:
-                        # Fallback to _base_manager
-                        created_base = base_model._base_manager.bulk_create(base_objects, **kwargs)
-                except RecursionError:
-                    # If recursion error, use _base_manager directly
-                    created_base = base_model._base_manager.bulk_create(base_objects, **kwargs)
-                
-                # Step 2: Update original objects with base IDs
-                for obj, base_obj in zip(class_objects, created_base):
-                    obj.pk = base_obj.pk
-                    obj._state.adding = False
-                
-                # Step 3: Bulk create child objects with hooks
-                child_objects = self._extract_child_objects(class_objects, obj_class)
-                if child_objects:
-                    # Use _base_manager to avoid recursion with custom managers
-                    try:
-                        obj_class._base_manager.bulk_create(child_objects, **kwargs)
-                    except RecursionError:
-                        # If recursion error, use individual saves
-                        for obj in child_objects:
-                            obj.save()
-                
-                result.extend(class_objects)
-                
-            except Exception as e:
-                # Add debugging information
-                import logging
-                logger = logging.getLogger(__name__)
-                logger.error(f"Error in _bulk_create_inherited for {obj_class}: {e}")
-                logger.error(f"Model fields: {[f.name for f in obj_class._meta.fields]}")
-                logger.error(f"Base model: {self._get_base_model(obj_class)}")
-                logger.error(f"Base model manager: {self._get_base_model(obj_class).objects}")
-                
-                # If it's a recursion error, try a simpler approach
-                if isinstance(e, RecursionError):
-                    logger.error("Recursion error detected, trying fallback approach")
-                    try:
-                        # Fallback: use individual saves
-                        for obj in class_objects:
-                            obj.save()
-                        result.extend(class_objects)
-                        continue
-                    except Exception as fallback_error:
-                        logger.error(f"Fallback approach also failed: {fallback_error}")
-                
-                raise
-        
-        return result
-
-    @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
-
-    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
-
-    @transaction.atomic
-    def bulk_create(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
-        model_cls = self.model
-
-        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)}"
-            )
-
-        # Check if this model uses multi-table inheritance
-        has_multi_table_inheritance = self._has_multi_table_inheritance(model_cls)
-
-        result = []
-
-        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)
-
-        # Perform bulk create in chunks
-        for i in range(0, len(objs), self.CHUNK_SIZE):
-            chunk = objs[i : i + self.CHUNK_SIZE]
-            
-            if has_multi_table_inheritance:
-                # Use our multi-table bulk create
-                created_chunk = self._bulk_create_inherited(chunk, **kwargs)
-            else:
-                # Use Django's standard bulk create
-                created_chunk = super(models.Manager, self).bulk_create(chunk, **kwargs)
-            
-            result.extend(created_chunk)
-
-        if not bypass_hooks:
-            engine.run(model_cls, AFTER_CREATE, result, ctx=ctx)
-
-        return result
-
-    @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