django-bulk-hooks 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

django_bulk_hooks/__init__.py

@@ -1,33 +1,29 @@
 import logging
 
+from django_bulk_hooks.changeset import ChangeSet
+from django_bulk_hooks.changeset import RecordChange
+from django_bulk_hooks.constants import DEFAULT_BULK_UPDATE_BATCH_SIZE
+from django_bulk_hooks.dispatcher import HookDispatcher
+from django_bulk_hooks.dispatcher import get_dispatcher
+from django_bulk_hooks.factory import clear_hook_factories
+from django_bulk_hooks.factory import configure_hook_container
+from django_bulk_hooks.factory import configure_nested_container
+from django_bulk_hooks.factory import create_hook_instance
+from django_bulk_hooks.factory import is_container_configured
+from django_bulk_hooks.factory import set_default_hook_factory
+from django_bulk_hooks.factory import set_hook_factory
 from django_bulk_hooks.handler import Hook as HookClass
+from django_bulk_hooks.helpers import build_changeset_for_create
+from django_bulk_hooks.helpers import build_changeset_for_delete
+from django_bulk_hooks.helpers import build_changeset_for_update
+from django_bulk_hooks.helpers import dispatch_hooks_for_operation
 from django_bulk_hooks.manager import BulkHookManager
-from django_bulk_hooks.factory import (
-    set_hook_factory,
-    set_default_hook_factory,
-    configure_hook_container,
-    configure_nested_container,
-    clear_hook_factories,
-    create_hook_instance,
-    is_container_configured,
-)
-from django_bulk_hooks.constants import DEFAULT_BULK_UPDATE_BATCH_SIZE
-from django_bulk_hooks.changeset import ChangeSet, RecordChange
-from django_bulk_hooks.dispatcher import get_dispatcher, HookDispatcher
-from django_bulk_hooks.helpers import (
-    build_changeset_for_create,
-    build_changeset_for_update,
-    build_changeset_for_delete,
-    dispatch_hooks_for_operation,
-)
+from django_bulk_hooks.operations import BulkExecutor
 
 # Service layer (NEW architecture)
-from django_bulk_hooks.operations import (
-    BulkOperationCoordinator,
-    ModelAnalyzer,
-    BulkExecutor,
-    MTIHandler,
-)
+from django_bulk_hooks.operations import BulkOperationCoordinator
+from django_bulk_hooks.operations import ModelAnalyzer
+from django_bulk_hooks.operations import MTIHandler
 
 # Add NullHandler to prevent logging messages if the application doesn't configure logging
 logging.getLogger(__name__).addHandler(logging.NullHandler())

django_bulk_hooks/changeset.py

@@ -226,5 +226,5 @@ class ChangeSet:
         for i in range(0, len(self.changes), chunk_size):
             chunk_changes = self.changes[i : i + chunk_size]
             yield ChangeSet(
-                self.model_cls, chunk_changes, self.operation_type, self.operation_meta
+                self.model_cls, chunk_changes, self.operation_type, self.operation_meta,
             )

django_bulk_hooks/conditions.py

@@ -19,9 +19,8 @@ def resolve_field_path(instance, field_path):
                 # For foreign key fields, use attname to get the ID directly
                 # This avoids hooking Django's descriptor protocol
                 return getattr(instance, field.attname, None)
-            else:
-                # For regular fields, use normal getattr
-                return getattr(instance, field_path, None)
+            # For regular fields, use normal getattr
+            return getattr(instance, field_path, None)
         except Exception:
             # If field lookup fails, fall back to normal getattr
             return getattr(instance, field_path, None)
@@ -41,7 +40,7 @@ def resolve_field_path(instance, field_path):
                     if field.is_relation and not field.many_to_many:
                         # Use attname for the final FK field access
                         current_instance = getattr(
-                            current_instance, field.attname, None
+                            current_instance, field.attname, None,
                         )
                         continue
                 except:
@@ -85,8 +84,7 @@ class IsNotEqual(HookCondition):
                 return False
             previous = resolve_field_path(original_instance, self.field)
             return previous == self.value and current != self.value
-        else:
-            return current != self.value
+        return current != self.value
 
 
 class IsEqual(HookCondition):
@@ -103,8 +101,7 @@ class IsEqual(HookCondition):
                 return False
             previous = resolve_field_path(original_instance, self.field)
             return previous != self.value and current == self.value
-        else:
-            return current == self.value
+        return current == self.value
 
 
 class HasChanged(HookCondition):
@@ -139,8 +136,7 @@ class WasEqual(HookCondition):
         if self.only_on_change:
             current = resolve_field_path(instance, self.field)
             return previous == self.value and current != self.value
-        else:
-            return previous == self.value
+        return previous == self.value
 
 
 class ChangesTo(HookCondition):
@@ -207,7 +203,7 @@ class AndCondition(HookCondition):
 
     def check(self, instance, original_instance=None):
         return self.cond1.check(instance, original_instance) and self.cond2.check(
-            instance, original_instance
+            instance, original_instance,
         )
 
 
@@ -218,7 +214,7 @@ class OrCondition(HookCondition):
 
     def check(self, instance, original_instance=None):
         return self.cond1.check(instance, original_instance) or self.cond2.check(
-            instance, original_instance
+            instance, original_instance,
         )
 
 

django_bulk_hooks/decorators.py

@@ -41,7 +41,7 @@ def select_related(*related_fields):
         def preload_related(records, *, model_cls=None, skip_fields=None):
             if not isinstance(records, list):
                 raise TypeError(
-                    f"@select_related expects a list of model instances, got {type(records)}"
+                    f"@select_related expects a list of model instances, got {type(records)}",
                 )
 
             if not records:
@@ -57,7 +57,7 @@ def select_related(*related_fields):
             for field in related_fields:
                 if "." in field:
                     raise ValueError(
-                        f"Invalid field notation '{field}'. Use Django ORM __ notation (e.g., 'parent__field')"
+                        f"Invalid field notation '{field}'. Use Django ORM __ notation (e.g., 'parent__field')",
                     )
 
             direct_relation_fields = {}
@@ -85,7 +85,7 @@ def select_related(*related_fields):
                     direct_relation_fields[field] = relation_field
 
             unsaved_related_ids_by_field = {
-                field: set() for field in direct_relation_fields.keys()
+                field: set() for field in direct_relation_fields
             }
 
             saved_ids_to_fetch = []
@@ -129,13 +129,13 @@ def select_related(*related_fields):
                 if base_manager is not None:
                     try:
                         fetched_saved = base_manager.select_related(
-                            *validated_fields
+                            *validated_fields,
                         ).in_bulk(saved_ids_to_fetch)
                     except Exception:
                         fetched_saved = {}
 
             fetched_unsaved_by_field = {
-                field: {} for field in direct_relation_fields.keys()
+                field: {} for field in direct_relation_fields
             }
 
             for field_name, relation_field in direct_relation_fields.items():
@@ -225,14 +225,14 @@ def select_related(*related_fields):
 
             if "new_records" not in bound.arguments:
                 raise TypeError(
-                    "@preload_related requires a 'new_records' argument in the decorated function"
+                    "@preload_related requires a 'new_records' argument in the decorated function",
                 )
 
             new_records = bound.arguments["new_records"]
 
             if not isinstance(new_records, list):
                 raise TypeError(
-                    f"@select_related expects a list of model instances, got {type(new_records)}"
+                    f"@select_related expects a list of model instances, got {type(new_records)}",
                 )
 
             if not new_records:
@@ -243,7 +243,7 @@ def select_related(*related_fields):
             for field in related_fields:
                 if "." in field:
                     raise ValueError(
-                        f"Invalid field notation '{field}'. Use Django ORM __ notation (e.g., 'parent__field')"
+                        f"Invalid field notation '{field}'. Use Django ORM __ notation (e.g., 'parent__field')",
                     )
 
             # Don't preload here - let the dispatcher handle it
@@ -285,18 +285,16 @@ def bulk_hook(model_cls, event, when=None, priority=None):
                 sig = inspect.signature(func)
                 params = list(sig.parameters.keys())
 
-                if 'changeset' in params:
+                if "changeset" in params:
                     # New signature with changeset
                     return self.func(changeset, new_records, old_records, **kwargs)
-                else:
-                    # Old signature without changeset
-                    # Only pass changeset in kwargs if the function accepts **kwargs
-                    if 'kwargs' in params or any(param.startswith('**') for param in sig.parameters):
-                        kwargs['changeset'] = changeset
-                        return self.func(new_records, old_records, **kwargs)
-                    else:
-                        # Function doesn't accept **kwargs, just call with positional args
-                        return self.func(new_records, old_records)
+                # Old signature without changeset
+                # Only pass changeset in kwargs if the function accepts **kwargs
+                if "kwargs" in params or any(param.startswith("**") for param in sig.parameters):
+                    kwargs["changeset"] = changeset
+                    return self.func(new_records, old_records, **kwargs)
+                # Function doesn't accept **kwargs, just call with positional args
+                return self.func(new_records, old_records)
 
         # Register the hook using the registry
         register_hook(

django_bulk_hooks/dispatcher.py

@@ -6,7 +6,6 @@ similar to Salesforce's hook framework.
 """
 
 import logging
-from typing import Optional
 
 logger = logging.getLogger(__name__)
 
@@ -162,30 +161,30 @@ class HookDispatcher:
                 model_cls_override = getattr(handler, "model_cls", None)
 
                 # Get FK fields being updated to avoid preloading conflicting relationships
-                skip_fields = changeset.operation_meta.get('fk_fields_being_updated', set())
+                skip_fields = changeset.operation_meta.get("fk_fields_being_updated", set())
 
                 # Preload for new_records
                 if filtered_changeset.new_records:
                     logger.debug(
                         f"Preloading relationships for {len(filtered_changeset.new_records)} "
-                        f"new_records for {handler_cls.__name__}.{method_name}"
+                        f"new_records for {handler_cls.__name__}.{method_name}",
                     )
                     preload_func(
                         filtered_changeset.new_records,
                         model_cls=model_cls_override,
-                        skip_fields=skip_fields
+                        skip_fields=skip_fields,
                     )
 
                 # Also preload for old_records (for conditions that check previous values)
                 if filtered_changeset.old_records:
                     logger.debug(
                         f"Preloading relationships for {len(filtered_changeset.old_records)} "
-                        f"old_records for {handler_cls.__name__}.{method_name}"
+                        f"old_records for {handler_cls.__name__}.{method_name}",
                     )
                     preload_func(
                         filtered_changeset.old_records,
                         model_cls=model_cls_override,
-                        skip_fields=skip_fields
+                        skip_fields=skip_fields,
                     )
             except Exception:
                 logger.debug(
@@ -196,15 +195,15 @@ class HookDispatcher:
                 )
 
         # Execute hook with ChangeSet
-        # 
+        #
         # ARCHITECTURE NOTE: Hook Contract
         # ====================================
         # All hooks must accept **kwargs for forward compatibility.
         # We pass: changeset, new_records, old_records
-        # 
+        #
         # Old hooks that don't use changeset: def hook(self, new_records, old_records, **kwargs)
         # New hooks that do use changeset:    def hook(self, changeset, new_records, old_records, **kwargs)
-        # 
+        #
         # This is standard Python framework design (see Django signals, Flask hooks, etc.)
         logger.info(f"    🚀 Executing: {handler_cls.__name__}.{method_name}")
         try:
@@ -224,7 +223,7 @@ class HookDispatcher:
 
 
 # Global dispatcher instance
-_dispatcher: Optional[HookDispatcher] = None
+_dispatcher: HookDispatcher | None = None
 
 
 def get_dispatcher():

django_bulk_hooks/factory.py

@@ -52,7 +52,8 @@ Usage Pattern 3 - Custom Resolver:
 import logging
 import re
 import threading
-from typing import Any, Callable, Optional, Type
+from collections.abc import Callable
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -69,11 +70,11 @@ class HookFactory:
 
     def __init__(self):
         """Initialize an empty factory."""
-        self._specific_factories: dict[Type, Callable[[], Any]] = {}
-        self._container_resolver: Optional[Callable[[Type], Any]] = None
+        self._specific_factories: dict[type, Callable[[], Any]] = {}
+        self._container_resolver: Callable[[type], Any] | None = None
         self._lock = threading.RLock()
 
-    def register_factory(self, hook_cls: Type, factory: Callable[[], Any]) -> None:
+    def register_factory(self, hook_cls: type, factory: Callable[[], Any]) -> None:
         """
         Register a factory function for a specific hook class.
 
@@ -98,8 +99,8 @@ class HookFactory:
     def configure_container(
         self,
         container: Any,
-        provider_name_resolver: Optional[Callable[[Type], str]] = None,
-        provider_resolver: Optional[Callable[[Any, Type, str], Any]] = None,
+        provider_name_resolver: Callable[[type], str] | None = None,
+        provider_resolver: Callable[[Any, type, str], Any] | None = None,
         fallback_to_direct: bool = True,
     ) -> None:
         """
@@ -142,7 +143,7 @@ class HookFactory:
         """
         name_resolver = provider_name_resolver or self._default_name_resolver
 
-        def resolver(hook_cls: Type) -> Any:
+        def resolver(hook_cls: type) -> Any:
             """Resolve hook instance from the container."""
             provider_name = name_resolver(hook_cls)
             name = getattr(hook_cls, "__name__", str(hook_cls))
@@ -155,8 +156,7 @@ class HookFactory:
                 except Exception as e:
                     if fallback_to_direct:
                         logger.debug(
-                            f"Custom provider resolver failed for {name} ({e}), "
-                            f"falling back to direct instantiation"
+                            f"Custom provider resolver failed for {name} ({e}), falling back to direct instantiation",
                         )
                         return hook_cls()
                     raise
@@ -165,34 +165,35 @@ class HookFactory:
             if hasattr(container, provider_name):
                 provider = getattr(container, provider_name)
                 logger.debug(
-                    f"Resolving {name} from container provider '{provider_name}'"
+                    f"Resolving {name} from container provider '{provider_name}'",
                 )
                 # Call the provider to get the instance
                 return provider()
 
             if fallback_to_direct:
                 logger.debug(
-                    f"Provider '{provider_name}' not found in container for {name}, "
-                    f"falling back to direct instantiation"
+                    f"Provider '{provider_name}' not found in container for {name}, falling back to direct instantiation",
                 )
                 return hook_cls()
 
             raise ValueError(
                 f"Hook {name} not found in container. "
                 f"Expected provider name: '{provider_name}'. "
-                f"Available providers: {[p for p in dir(container) if not p.startswith('_')]}"
+                f"Available providers: {[p for p in dir(container) if not p.startswith('_')]}",
             )
 
         with self._lock:
             self._container_resolver = resolver
             container_name = getattr(
-                container.__class__, "__name__", str(container.__class__)
+                container.__class__,
+                "__name__",
+                str(container.__class__),
             )
             logger.info(
-                f"Configured hook factory to use container: {container_name}"
+                f"Configured hook factory to use container: {container_name}",
             )
 
-    def create(self, hook_cls: Type) -> Any:
+    def create(self, hook_cls: type) -> Any:
         """
         Create a hook instance using the configured resolution strategy.
 
@@ -249,7 +250,7 @@ class HookFactory:
         with self._lock:
             return self._container_resolver is not None
 
-    def has_factory(self, hook_cls: Type) -> bool:
+    def has_factory(self, hook_cls: type) -> bool:
         """
         Check if a hook class has a registered factory.
 
@@ -262,7 +263,7 @@ class HookFactory:
         with self._lock:
             return hook_cls in self._specific_factories
 
-    def get_factory(self, hook_cls: Type) -> Optional[Callable[[], Any]]:
+    def get_factory(self, hook_cls: type) -> Callable[[], Any] | None:
         """
         Get the registered factory for a specific hook class.
 
@@ -275,7 +276,7 @@ class HookFactory:
         with self._lock:
             return self._specific_factories.get(hook_cls)
 
-    def list_factories(self) -> dict[Type, Callable]:
+    def list_factories(self) -> dict[type, Callable]:
         """
         Get a copy of all registered hook factories.
 
@@ -286,7 +287,7 @@ class HookFactory:
             return self._specific_factories.copy()
 
     @staticmethod
-    def _default_name_resolver(hook_cls: Type) -> str:
+    def _default_name_resolver(hook_cls: type) -> str:
         """
         Default naming convention: LoanAccountHook -> loan_account_hook
 
@@ -303,7 +304,7 @@ class HookFactory:
 
 
 # Global singleton factory
-_factory: Optional[HookFactory] = None
+_factory: HookFactory | None = None
 _factory_lock = threading.Lock()
 
 
@@ -329,7 +330,7 @@ def get_factory() -> HookFactory:
 
 
 # Backward-compatible module-level functions
-def set_hook_factory(hook_cls: Type, factory: Callable[[], Any]) -> None:
+def set_hook_factory(hook_cls: type, factory: Callable[[], Any]) -> None:
     """
     Register a factory function for a specific hook class.
 
@@ -350,7 +351,7 @@ def set_hook_factory(hook_cls: Type, factory: Callable[[], Any]) -> None:
     hook_factory.register_factory(hook_cls, factory)
 
 
-def set_default_hook_factory(factory: Callable[[Type], Any]) -> None:
+def set_default_hook_factory(factory: Callable[[type], Any]) -> None:
     """
     DEPRECATED: Use configure_hook_container with provider_resolver instead.
 
@@ -363,8 +364,7 @@ def set_default_hook_factory(factory: Callable[[Type], Any]) -> None:
     import warnings
 
     warnings.warn(
-        "set_default_hook_factory is deprecated. "
-        "Use configure_hook_container with provider_resolver instead.",
+        "set_default_hook_factory is deprecated. Use configure_hook_container with provider_resolver instead.",
         DeprecationWarning,
         stacklevel=2,
     )
@@ -379,8 +379,8 @@ def set_default_hook_factory(factory: Callable[[Type], Any]) -> None:
 
 def configure_hook_container(
     container: Any,
-    provider_name_resolver: Optional[Callable[[Type], str]] = None,
-    provider_resolver: Optional[Callable[[Any, Type, str], Any]] = None,
+    provider_name_resolver: Callable[[type], str] | None = None,
+    provider_resolver: Callable[[Any, type, str], Any] | None = None,
     fallback_to_direct: bool = True,
 ) -> None:
     """
@@ -415,7 +415,7 @@ def configure_hook_container(
 def configure_nested_container(
     container: Any,
     container_path: str,
-    provider_name_resolver: Optional[Callable[[Type], str]] = None,
+    provider_name_resolver: Callable[[type], str] | None = None,
     fallback_to_direct: bool = True,
 ) -> None:
     """
@@ -444,8 +444,7 @@ def configure_nested_container(
     import warnings
 
     warnings.warn(
-        "configure_nested_container is deprecated. "
-        "Use configure_hook_container with provider_resolver instead.",
+        "configure_nested_container is deprecated. Use configure_hook_container with provider_resolver instead.",
         DeprecationWarning,
         stacklevel=2,
     )
@@ -457,7 +456,7 @@ def configure_nested_container(
         for part in container_path.split("."):
             if not hasattr(current, part):
                 raise ValueError(
-                    f"Container path '{container_path}' not found. Missing: {part}"
+                    f"Container path '{container_path}' not found. Missing: {part}",
                 )
             provider = getattr(current, part)
             # Call provider to get next level
@@ -466,13 +465,12 @@ def configure_nested_container(
         # Get the hook provider from sub-container
         if not hasattr(current, provider_name):
             raise ValueError(
-                f"Provider '{provider_name}' not found in sub-container. "
-                f"Available: {[p for p in dir(current) if not p.startswith('_')]}"
+                f"Provider '{provider_name}' not found in sub-container. Available: {[p for p in dir(current) if not p.startswith('_')]}",
             )
 
         hook_provider = getattr(current, provider_name)
         logger.debug(
-            f"Resolved {hook_cls.__name__} from {container_path}.{provider_name}"
+            f"Resolved {hook_cls.__name__} from {container_path}.{provider_name}",
         )
         return hook_provider()
 
@@ -493,7 +491,7 @@ def clear_hook_factories() -> None:
     hook_factory.clear()
 
 
-def create_hook_instance(hook_cls: Type) -> Any:
+def create_hook_instance(hook_cls: type) -> Any:
     """
     Create a hook instance using the configured resolution strategy.
 
@@ -515,7 +513,7 @@ def create_hook_instance(hook_cls: Type) -> Any:
     return hook_factory.create(hook_cls)
 
 
-def get_hook_factory(hook_cls: Type) -> Optional[Callable[[], Any]]:
+def get_hook_factory(hook_cls: type) -> Callable[[], Any] | None:
     """
     Get the registered factory for a specific hook class.
 
@@ -529,7 +527,7 @@ def get_hook_factory(hook_cls: Type) -> Optional[Callable[[], Any]]:
     return hook_factory.get_factory(hook_cls)
 
 
-def has_hook_factory(hook_cls: Type) -> bool:
+def has_hook_factory(hook_cls: type) -> bool:
     """
     Check if a hook class has a registered factory.
 
@@ -554,7 +552,7 @@ def is_container_configured() -> bool:
     return hook_factory.is_container_configured()
 
 
-def list_registered_factories() -> dict[Type, Callable]:
+def list_registered_factories() -> dict[type, Callable]:
     """
     Get a copy of all registered hook factories.
 

django_bulk_hooks/handler.py

@@ -8,7 +8,7 @@ logger = logging.getLogger(__name__)
 class HookMeta(type):
     _registered = set()
     _class_hook_map: dict[
-        type, set[tuple]
+        type, set[tuple],
     ] = {}  # Track which hooks belong to which class
 
     def __new__(mcs, name, bases, namespace):
@@ -25,7 +25,7 @@ class HookMeta(type):
         - Child overrides replace parent implementations (not add to them)
         - Child can add new hook methods
         """
-        from django_bulk_hooks.registry import register_hook, unregister_hook
+        from django_bulk_hooks.registry import unregister_hook
 
         # Step 1: Unregister ALL hooks from parent classes in the MRO
         # This ensures only the most-derived class owns the active hooks,
@@ -36,7 +36,7 @@ class HookMeta(type):
 
             if base in mcs._class_hook_map:
                 for model_cls, event, base_cls, method_name in list(
-                    mcs._class_hook_map[base]
+                    mcs._class_hook_map[base],
                 ):
                     key = (model_cls, event, base_cls, method_name)
                     if key in HookMeta._registered:
@@ -44,7 +44,7 @@ class HookMeta(type):
                         HookMeta._registered.discard(key)
                         logger.debug(
                             f"Unregistered base hook: {base_cls.__name__}.{method_name} "
-                            f"(superseded by {cls.__name__})"
+                            f"(superseded by {cls.__name__})",
                         )
 
         # Step 2: Register all hook methods on this class (including inherited ones)
@@ -79,7 +79,7 @@ class HookMeta(type):
                         mcs._class_hook_map[cls].add(key)
                         logger.debug(
                             f"Registered hook: {cls.__name__}.{method_name} "
-                            f"for {model_cls.__name__}.{event}"
+                            f"for {model_cls.__name__}.{event}",
                         )
 
     @classmethod
@@ -112,4 +112,3 @@ class Hook(metaclass=HookMeta):
     a single, consistent execution path.
     """
 
-    pass

django_bulk_hooks/helpers.py

@@ -8,11 +8,12 @@ NOTE: These helpers are pure changeset builders - they don't fetch data.
 Data fetching is the responsibility of ModelAnalyzer.
 """
 
-from django_bulk_hooks.changeset import ChangeSet, RecordChange
+from django_bulk_hooks.changeset import ChangeSet
+from django_bulk_hooks.changeset import RecordChange
 
 
 def build_changeset_for_update(
-    model_cls, instances, update_kwargs, old_records_map=None, **meta
+    model_cls, instances, update_kwargs, old_records_map=None, **meta,
 ):
     """
     Build ChangeSet for update operations.
@@ -32,7 +33,7 @@ def build_changeset_for_update(
 
     changes = [
         RecordChange(
-            new, old_records_map.get(new.pk), changed_fields=list(update_kwargs.keys())
+            new, old_records_map.get(new.pk), changed_fields=list(update_kwargs.keys()),
         )
         for new in instances
     ]

django_bulk_hooks/models.py

@@ -28,7 +28,7 @@ class HookModelMixin(models.Model):
         # Delegate to coordinator (consistent with save/delete)
         is_create = self.pk is None
         self.__class__.objects.get_queryset().coordinator.clean(
-            [self], is_create=is_create
+            [self], is_create=is_create,
         )
 
     def save(self, *args, bypass_hooks=False, **kwargs):
@@ -48,18 +48,17 @@ class HookModelMixin(models.Model):
             # Delegate to bulk_create which handles all hook logic
             result = self.__class__.objects.bulk_create([self])
             return result[0] if result else self
-        else:
-            # Delegate to bulk_update which handles all hook logic
-            update_fields = kwargs.get("update_fields")
-            if update_fields is None:
-                # Update all non-auto fields
-                update_fields = [
-                    f.name
-                    for f in self.__class__._meta.fields
-                    if not f.auto_created and f.name != "id"
-                ]
-            self.__class__.objects.bulk_update([self], update_fields)
-            return self
+        # Delegate to bulk_update which handles all hook logic
+        update_fields = kwargs.get("update_fields")
+        if update_fields is None:
+            # Update all non-auto fields
+            update_fields = [
+                f.name
+                for f in self.__class__._meta.fields
+                if not f.auto_created and f.name != "id"
+            ]
+        self.__class__.objects.bulk_update([self], update_fields)
+        return self
 
     def delete(self, *args, bypass_hooks=False, **kwargs):
         """