django-bulk-hooks 0.1.83__py3-none-any.whl → 0.2.100__py3-none-any.whl

django_bulk_hooks/registry.py

@@ -1,25 +1,276 @@
-from collections.abc import Callable
-from typing import Union
-
-from django_bulk_hooks.enums import Priority
-
-_hooks: dict[tuple[type, str], list[tuple[type, str, Callable, int]]] = {}
-
-
-def register_hook(
-    model, event, handler_cls, method_name, condition, priority: Union[int, Priority]
-):
-    key = (model, event)
-    hooks = _hooks.setdefault(key, [])
-    hooks.append((handler_cls, method_name, condition, priority))
-    # keep sorted by priority
-    hooks.sort(key=lambda x: x[3])
-
-
-def get_hooks(model, event):
-    return _hooks.get((model, event), [])
-
-
-def list_all_hooks():
-    """Debug function to list all registered hooks"""
-    return _hooks
+"""
+Central registry for hook handlers.
+
+Provides thread-safe registration and lookup of hooks with
+deterministic priority ordering.
+"""
+
+import logging
+import threading
+from collections.abc import Callable
+
+from django_bulk_hooks.enums import Priority
+
+logger = logging.getLogger(__name__)
+
+# Type alias for hook info tuple
+HookInfo = tuple[type, str, Callable | None, int]
+
+
+class HookRegistry:
+    """
+    Central registry for all hook handlers.
+
+    Manages registration, lookup, and lifecycle of hooks with
+    thread-safe operations and deterministic ordering by priority.
+
+    This is a singleton - use get_registry() to access the instance.
+    """
+
+    def __init__(self):
+        """Initialize an empty registry with thread-safe storage."""
+        self._hooks: dict[tuple[type, str], list[HookInfo]] = {}
+        self._lock = threading.RLock()
+
+    def register(
+        self,
+        model: type,
+        event: str,
+        handler_cls: type,
+        method_name: str,
+        condition: Callable | None,
+        priority: int | Priority,
+    ) -> None:
+        """
+        Register a hook handler for a model and event.
+
+        Args:
+            model: Django model class
+            event: Event name (e.g., 'after_update', 'before_create')
+            handler_cls: Hook handler class
+            method_name: Name of the method to call on handler
+            condition: Optional condition to filter records
+            priority: Execution priority (lower values execute first)
+        """
+        with self._lock:
+            key = (model, event)
+            hooks = self._hooks.setdefault(key, [])
+
+            # Check for duplicates before adding
+            hook_info = (handler_cls, method_name, condition, priority)
+            if hook_info not in hooks:
+                hooks.append(hook_info)
+                # Sort by priority (lower values first)
+                hooks.sort(key=lambda x: x[3])
+            else:
+                pass  # Hook already registered
+
+    def get_hooks(self, model: type, event: str) -> list[HookInfo]:
+        """
+        Get all hooks for a model and event.
+
+        Args:
+            model: Django model class
+            event: Event name
+
+        Returns:
+            List of hook info tuples (handler_cls, method_name, condition, priority)
+            sorted by priority (lower values first)
+        """
+        with self._lock:
+            key = (model, event)
+            hooks = self._hooks.get(key, [])
+            logger.debug(f"Retrieved {len(hooks)} hooks for {model.__name__}.{event}")
+            return hooks
+
+    def unregister(
+        self,
+        model: type,
+        event: str,
+        handler_cls: type,
+        method_name: str,
+    ) -> None:
+        """
+        Unregister a specific hook handler.
+
+        Used when child classes override parent hook methods.
+
+        Args:
+            model: Django model class
+            event: Event name
+            handler_cls: Hook handler class to remove
+            method_name: Method name to remove
+        """
+        with self._lock:
+            key = (model, event)
+            if key not in self._hooks:
+                return
+
+            hooks = self._hooks[key]
+            # Filter out the specific hook
+            self._hooks[key] = [
+                (h_cls, m_name, cond, pri) for h_cls, m_name, cond, pri in hooks if not (h_cls == handler_cls and m_name == method_name)
+            ]
+
+            # Clean up empty hook lists
+            if not self._hooks[key]:
+                del self._hooks[key]
+
+    def clear(self) -> None:
+        """
+        Clear all registered hooks.
+
+        Useful for testing to ensure clean state between tests.
+        """
+        with self._lock:
+            self._hooks.clear()
+
+            # Also clear HookMeta state to ensure complete reset
+            from django_bulk_hooks.handler import HookMeta
+
+            HookMeta._registered.clear()
+            HookMeta._class_hook_map.clear()
+
+    def list_all(self) -> dict[tuple[type, str], list[HookInfo]]:
+        """
+        Get all registered hooks for debugging.
+
+        Returns:
+            Dictionary mapping (model, event) tuples to lists of hook info
+        """
+        with self._lock:
+            return dict(self._hooks)
+
+    @property
+    def hooks(self) -> dict[tuple[type, str], list[HookInfo]]:
+        """
+        Expose internal hooks dictionary for testing purposes.
+
+        This property provides direct access to the internal hooks storage
+        to allow tests to clear the registry state between test runs.
+        """
+        return self._hooks
+
+    def count_hooks(
+        self,
+        model: type | None = None,
+        event: str | None = None,
+    ) -> int:
+        """
+        Count registered hooks, optionally filtered by model and/or event.
+
+        Args:
+            model: Optional model class to filter by
+            event: Optional event name to filter by
+
+        Returns:
+            Number of matching hooks
+        """
+        with self._lock:
+            if model is None and event is None:
+                # Count all hooks
+                return sum(len(hooks) for hooks in self._hooks.values())
+            if model is not None and event is not None:
+                # Count hooks for specific model and event
+                return len(self._hooks.get((model, event), []))
+            if model is not None:
+                # Count all hooks for a model
+                return sum(len(hooks) for (m, _), hooks in self._hooks.items() if m == model)
+            # event is not None
+            # Count all hooks for an event
+            return sum(len(hooks) for (_, e), hooks in self._hooks.items() if e == event)
+
+
+# Global singleton registry
+_registry: HookRegistry | None = None
+_registry_lock = threading.Lock()
+
+
+def get_registry() -> HookRegistry:
+    """
+    Get the global hook registry instance.
+
+    Creates the registry on first access (singleton pattern).
+    Thread-safe initialization.
+
+    Returns:
+        HookRegistry singleton instance
+    """
+    global _registry
+
+    if _registry is None:
+        with _registry_lock:
+            # Double-checked locking
+            if _registry is None:
+                _registry = HookRegistry()
+
+    return _registry
+
+
+# Backward-compatible module-level functions
+def register_hook(
+    model: type,
+    event: str,
+    handler_cls: type,
+    method_name: str,
+    condition: Callable | None,
+    priority: int | Priority,
+) -> None:
+    """
+    Register a hook handler (backward-compatible function).
+
+    Delegates to the global registry instance.
+    """
+    registry = get_registry()
+    registry.register(model, event, handler_cls, method_name, condition, priority)
+
+
+def get_hooks(model: type, event: str) -> list[HookInfo]:
+    """
+    Get hooks for a model and event (backward-compatible function).
+
+    Delegates to the global registry instance.
+    """
+    registry = get_registry()
+    return registry.get_hooks(model, event)
+
+
+def unregister_hook(
+    model: type,
+    event: str,
+    handler_cls: type,
+    method_name: str,
+) -> None:
+    """
+    Unregister a hook handler (backward-compatible function).
+
+    Delegates to the global registry instance.
+    """
+    registry = get_registry()
+    registry.unregister(model, event, handler_cls, method_name)
+
+
+def clear_hooks() -> None:
+    """
+    Clear all registered hooks (backward-compatible function).
+
+    Delegates to the global registry instance.
+    Useful for testing.
+    """
+    registry = get_registry()
+    registry.clear()
+
+
+def list_all_hooks() -> dict[tuple[type, str], list[HookInfo]]:
+    """
+    List all registered hooks (backward-compatible function).
+
+    Delegates to the global registry instance.
+    """
+    registry = get_registry()
+    return registry.list_all()
+
+
+# Expose hooks dictionary for testing purposes
+# This provides backward compatibility with tests that expect to access _hooks directly
+_hooks = get_registry().hooks

django_bulk_hooks-0.2.100.dist-info/METADATA

@@ -0,0 +1,320 @@
+Metadata-Version: 2.3
+Name: django-bulk-hooks
+Version: 0.2.100
+Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
+License: MIT
+Keywords: django,bulk,hooks
+Author: Konrad Beck
+Author-email: konrad.beck@merchantcapital.co.za
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: django (>=5.2.0,<6.0.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
+
+
+# django-bulk-hooks
+
+⚡ Bulk hooks for Django bulk operations and individual model lifecycle events.
+
+`django-bulk-hooks` brings a declarative, hook-like experience to Django's `bulk_create`, `bulk_update`, and `bulk_delete` — including support for `BEFORE_` and `AFTER_` hooks, conditions, batching, and transactional safety. It also provides comprehensive lifecycle hooks for individual model operations.
+
+## ✨ Features
+
+- Declarative hook system: `@hook(AFTER_UPDATE, condition=...)`
+- BEFORE/AFTER hooks for create, update, delete
+- Hook-aware manager that wraps Django's `bulk_` operations
+- **NEW**: `HookModelMixin` for individual model lifecycle events
+- Hook chaining, hook deduplication, and atomicity
+- Class-based hook handlers with DI support
+- Support for both bulk and individual model operations
+
+## 🚀 Quickstart
+
+```bash
+pip install django-bulk-hooks
+```
+
+### Define Your Model
+
+```python
+from django.db import models
+from django_bulk_hooks.models import HookModelMixin
+
+class Account(HookModelMixin):
+    balance = models.DecimalField(max_digits=10, decimal_places=2)
+    # The HookModelMixin automatically provides BulkHookManager
+```
+
+### Create a Hook Handler
+
+```python
+from django_bulk_hooks import hook, AFTER_UPDATE, Hook
+from django_bulk_hooks.conditions import WhenFieldHasChanged
+from .models import Account
+
+class AccountHooks(Hook):
+    @hook(AFTER_UPDATE, model=Account, condition=WhenFieldHasChanged("balance"))
+    def log_balance_change(self, new_records, old_records):
+        print("Accounts updated:", [a.pk for a in new_records])
+    
+    @hook(BEFORE_CREATE, model=Account)
+    def before_create(self, new_records, old_records):
+        for account in new_records:
+            if account.balance < 0:
+                raise ValueError("Account cannot have negative balance")
+    
+    @hook(AFTER_DELETE, model=Account)
+    def after_delete(self, new_records, old_records):
+        print("Accounts deleted:", [a.pk for a in old_records])
+```
+
+## 🛠 Supported Hook Events
+
+- `BEFORE_CREATE`, `AFTER_CREATE`
+- `BEFORE_UPDATE`, `AFTER_UPDATE`
+- `BEFORE_DELETE`, `AFTER_DELETE`
+
+## 🔄 Lifecycle Events
+
+### Individual Model Operations
+
+The `HookModelMixin` automatically hooks hooks for individual model operations:
+
+```python
+# These will hook BEFORE_CREATE and AFTER_CREATE hooks
+account = Account.objects.create(balance=100.00)
+account.save()  # for new instances
+
+# These will hook BEFORE_UPDATE and AFTER_UPDATE hooks
+account.balance = 200.00
+account.save()  # for existing instances
+
+# This will hook BEFORE_DELETE and AFTER_DELETE hooks
+account.delete()
+```
+
+### Bulk Operations
+
+Bulk operations also hook the same hooks:
+
+```python
+# Bulk create - hooks BEFORE_CREATE and AFTER_CREATE hooks
+accounts = [
+    Account(balance=100.00),
+    Account(balance=200.00),
+]
+Account.objects.bulk_create(accounts)
+
+# Bulk update - hooks BEFORE_UPDATE and AFTER_UPDATE hooks
+for account in accounts:
+    account.balance *= 1.1
+Account.objects.bulk_update(accounts)  # fields are auto-detected
+
+# Bulk delete - hooks BEFORE_DELETE and AFTER_DELETE hooks
+Account.objects.bulk_delete(accounts)
+```
+
+### Queryset Operations
+
+Queryset operations are also supported:
+
+```python
+# Queryset update - hooks BEFORE_UPDATE and AFTER_UPDATE hooks
+Account.objects.update(balance=0.00)
+
+# Queryset delete - hooks BEFORE_DELETE and AFTER_DELETE hooks
+Account.objects.delete()
+```
+
+### Subquery Support in Updates
+
+When using `Subquery` objects in update operations, the computed values are automatically available in hooks. The system efficiently refreshes all instances in bulk for optimal performance:
+
+```python
+from django.db.models import Subquery, OuterRef, Sum
+
+def aggregate_revenue_by_ids(self, ids: Iterable[int]) -> int:
+    return self.find_by_ids(ids).update(
+        revenue=Subquery(
+            FinancialTransaction.objects.filter(daily_financial_aggregate_id=OuterRef("pk"))
+            .filter(is_revenue=True)
+            .values("daily_financial_aggregate_id")
+            .annotate(revenue_sum=Sum("amount"))
+            .values("revenue_sum")[:1],
+        ),
+    )
+
+# In your hooks, you can now access the computed revenue value:
+class FinancialAggregateHooks(Hook):
+    @hook(AFTER_UPDATE, model=DailyFinancialAggregate)
+    def log_revenue_update(self, new_records, old_records):
+        for new_record in new_records:
+            # This will now contain the computed value, not the Subquery object
+            print(f"Updated revenue: {new_record.revenue}")
+
+# Bulk operations are optimized for performance:
+def bulk_aggregate_revenue(self, ids: Iterable[int]) -> int:
+    # This will efficiently refresh all instances in a single query
+    return self.filter(id__in=ids).update(
+        revenue=Subquery(
+            FinancialTransaction.objects.filter(daily_financial_aggregate_id=OuterRef("pk"))
+            .filter(is_revenue=True)
+            .values("daily_financial_aggregate_id")
+            .annotate(revenue_sum=Sum("amount"))
+            .values("revenue_sum")[:1],
+        ),
+    )
+```
+
+## 🧠 Why?
+
+Django's `bulk_` methods bypass signals and `save()`. This package fills that gap with:
+
+- Hooks that behave consistently across creates/updates/deletes
+- **NEW**: Individual model lifecycle hooks that work with `save()` and `delete()`
+- Scalable performance via chunking (default 200)
+- Support for `@hook` decorators and centralized hook classes
+- **NEW**: Automatic hook hooking for admin operations and other Django features
+- **NEW**: Proper ordering guarantees for old/new record pairing in hooks (Salesforce-like behavior)
+
+## 📦 Usage Examples
+
+### Individual Model Operations
+
+```python
+# These automatically hook hooks
+account = Account.objects.create(balance=100.00)
+account.balance = 200.00
+account.save()
+account.delete()
+```
+
+### Bulk Operations
+
+```python
+# These also hook hooks
+Account.objects.bulk_create(accounts)
+Account.objects.bulk_update(accounts)  # fields are auto-detected
+Account.objects.bulk_delete(accounts)
+```
+
+### Advanced Hook Usage
+
+```python
+class AdvancedAccountHooks(Hook):
+    @hook(BEFORE_UPDATE, model=Account, condition=WhenFieldHasChanged("balance"))
+    def validate_balance_change(self, new_records, old_records):
+        for new_account, old_account in zip(new_records, old_records):
+            if new_account.balance < 0 and old_account.balance >= 0:
+                raise ValueError("Cannot set negative balance")
+    
+    @hook(AFTER_CREATE, model=Account)
+    def send_welcome_email(self, new_records, old_records):
+        for account in new_records:
+            # Send welcome email logic here
+            pass
+```
+
+### Salesforce-like Ordering Guarantees
+
+The system ensures that `old_records` and `new_records` are always properly paired, regardless of the order in which you pass objects to bulk operations:
+
+```python
+class LoanAccountHooks(Hook):
+    @hook(BEFORE_UPDATE, model=LoanAccount)
+    def validate_account_number(self, new_records, old_records):
+        # old_records[i] always corresponds to new_records[i]
+        for new_account, old_account in zip(new_records, old_records):
+            if old_account.account_number != new_account.account_number:
+                raise ValidationError("Account number cannot be changed")
+
+# This works correctly even with reordered objects:
+accounts = [account1, account2, account3]  # IDs: 1, 2, 3
+reordered = [account3, account1, account2]  # IDs: 3, 1, 2
+
+# The hook will still receive properly paired old/new records
+LoanAccount.objects.bulk_update(reordered)  # fields are auto-detected
+```
+
+## 🧩 Integration with Other Managers
+
+### Recommended: QuerySet-based Composition (New Approach)
+
+For the best compatibility and to avoid inheritance conflicts, use the queryset-based composition approach:
+
+```python
+from django_bulk_hooks.queryset import HookQuerySet
+from queryable_properties.managers import QueryablePropertiesManager
+
+class MyManager(QueryablePropertiesManager):
+    """Manager that combines queryable properties with hooks"""
+
+    def get_queryset(self):
+        # Get the QueryableProperties QuerySet
+        qs = super().get_queryset()
+        # Apply hooks on top of it
+        return HookQuerySet.with_hooks(qs)
+
+class Article(models.Model):
+    title = models.CharField(max_length=100)
+    published = models.BooleanField(default=False)
+
+    objects = MyManager()
+
+# This gives you both queryable properties AND hooks
+# No inheritance conflicts, no MRO issues!
+```
+
+### Alternative: Explicit Hook Application
+
+For more control, you can apply hooks explicitly:
+
+```python
+class MyManager(QueryablePropertiesManager):
+    def get_queryset(self):
+        return super().get_queryset()
+
+    def with_hooks(self):
+        """Apply hooks to this queryset"""
+        return HookQuerySet.with_hooks(self.get_queryset())
+
+# Usage:
+Article.objects.with_hooks().filter(published=True).update(title="Updated")
+```
+
+### Legacy: Manager Inheritance (Not Recommended)
+
+The old inheritance approach still works but is not recommended due to potential MRO conflicts:
+
+```python
+from django_bulk_hooks.manager import BulkHookManager
+from queryable_properties.managers import QueryablePropertiesManager
+
+class MyManager(BulkHookManager, QueryablePropertiesManager):
+    pass  # ⚠️ Can cause inheritance conflicts
+```
+
+**Why the new approach is better:**
+- ✅ No inheritance conflicts
+- ✅ No MRO (Method Resolution Order) issues
+- ✅ Works with any manager combination
+- ✅ Cleaner and more maintainable
+- ✅ Follows Django's queryset enhancement patterns
+
+Framework needs to:
+Register these methods
+Know when to execute them (BEFORE_UPDATE, AFTER_UPDATE)
+Execute them in priority order
+Pass ChangeSet to them
+Handle errors (rollback on failure)
+
+## 📝 License
+
+MIT © 2024 Augend / Konrad Beck
+

django_bulk_hooks-0.2.100.dist-info/RECORD

@@ -0,0 +1,27 @@
+django_bulk_hooks/__init__.py,sha256=ZKjEi9Sj3lRr3hcEfknXAr1UXXwERzUCNgMkNXhW0mk,2119
+django_bulk_hooks/changeset.py,sha256=qnMD3bR2cNh8ZM8J6ASR5ly5Rjx-tPzXBYkqIjKGW98,6568
+django_bulk_hooks/conditions.py,sha256=ar4pGjtxLKmgSIlO4S6aZFKmaBNchLtxMmWpkn4g9RU,8114
+django_bulk_hooks/constants.py,sha256=PxpEETaO6gdENcTPoXS586lerGKVP3nmjpDvOkmhYxI,509
+django_bulk_hooks/context.py,sha256=mqaC5-yESDTA5ruI7fuXlt8qSgKuOFp0mjq7h1-4HdQ,1926
+django_bulk_hooks/decorators.py,sha256=TdkO4FJyFrVU2zqK6Y_6JjEJ4v3nbKkk7aa22jN10sk,11994
+django_bulk_hooks/dispatcher.py,sha256=EiFthoPKsgEsJEh1Xf0X2hS3-QJ1a0qFijPJ9ebng6k,26994
+django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
+django_bulk_hooks/factory.py,sha256=ezrVM5U023KZqOBbJXb6lYUP-pE7WJmi8Olh2Ew-7RA,18085
+django_bulk_hooks/handler.py,sha256=SRCrMzgolrruTkvMnYBFmXLR-ABiw0JiH3605PEdCZM,4207
+django_bulk_hooks/helpers.py,sha256=3rH9TJkdCPF7Vu--0tDaZzJg9Yxcv7yoSF1K1_-0psQ,8048
+django_bulk_hooks/manager.py,sha256=sn4ALCuxRydjIJ91kB81Dhj4PitwytGa4wzxPos4I2Q,4096
+django_bulk_hooks/models.py,sha256=H16AuIiRjkwTD-YDA9S_sMYfAzAFoBgKqiq4TvJuJ9M,3325
+django_bulk_hooks/operations/__init__.py,sha256=BtJYjmRhe_sScivLsniDaZmBkm0ZLvcmzXFKL7QY2Xg,550
+django_bulk_hooks/operations/analyzer.py,sha256=Fw4rjkhpfT8b2A4c7CSMfFRtLUFVimCCz_eGIBtcNiI,15126
+django_bulk_hooks/operations/bulk_executor.py,sha256=URoZVkR-vKMgwLRrNe9aqoRV2i6vLJPr6N-E8CW5npY,29116
+django_bulk_hooks/operations/coordinator.py,sha256=3n9bKpcn3_X-zos0tYX6JWS77JleeYMVawZu2DZ1LC4,34973
+django_bulk_hooks/operations/field_utils.py,sha256=o07oKib6cN8YfFB13O-1YksFr_W9LMlA4Q0rKYskrco,14518
+django_bulk_hooks/operations/mti_handler.py,sha256=00djtjfZ0rrOfiEii8TS1aBarC0qDpCBsFfWGrljvsc,26946
+django_bulk_hooks/operations/mti_plans.py,sha256=HIRJgogHPpm6MV7nZZ-sZhMLUnozpZPV2SzwQHLRzYc,3667
+django_bulk_hooks/operations/record_classifier.py,sha256=It85hJC2K-UsEOLbTR-QBdY5UPV-acQIJ91TSGa7pYo,7053
+django_bulk_hooks/queryset.py,sha256=tPIkNESb47fTIpTrR6xUtc-k3gCFR15W0Xt2-HmvlJo,6811
+django_bulk_hooks/registry.py,sha256=4HxP1mVK2z4VzvlohbEw2359wM21UJZJYagJJ1komM0,7947
+django_bulk_hooks-0.2.100.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.2.100.dist-info/METADATA,sha256=nEA9mRH3Cmy-WDAUF4M3rUOzQw4GOgOXSN_0vmCP9UY,10556
+django_bulk_hooks-0.2.100.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.2.100.dist-info/RECORD,,

django_bulk_hooks/engine.py

@@ -1,53 +0,0 @@
-import logging
-
-from django.core.exceptions import ValidationError
-from django.db import models
-from django_bulk_hooks.registry import get_hooks
-from django_bulk_hooks.conditions import safe_get_related_object, safe_get_related_attr
-
-logger = logging.getLogger(__name__)
-
-
-def run(model_cls, event, new_instances, original_instances=None, ctx=None):
-    hooks = get_hooks(model_cls, event)
-
-    if not hooks:
-        return
-
-    # For BEFORE_* events, run model.clean() first for validation
-    if event.startswith("before_"):
-        for instance in new_instances:
-            try:
-                instance.clean()
-            except ValidationError as e:
-                logger.error("Validation failed for %s: %s", instance, e)
-                raise
-            except Exception as e:
-                # Handle RelatedObjectDoesNotExist and other exceptions that might occur
-                # when accessing foreign key fields on unsaved objects
-                if "RelatedObjectDoesNotExist" in str(type(e).__name__):
-                    logger.debug("Skipping validation for unsaved object with unset foreign keys: %s", e)
-                    continue
-                else:
-                    logger.error("Unexpected error during validation for %s: %s", instance, e)
-                    raise
-
-    for handler_cls, method_name, condition, priority in hooks:
-        handler_instance = handler_cls()
-        func = getattr(handler_instance, method_name)
-
-        to_process_new = []
-        to_process_old = []
-
-        for new, original in zip(
-            new_instances,
-            original_instances or [None] * len(new_instances),
-            strict=True,
-        ):
-            if not condition or condition.check(new, original):
-                to_process_new.append(new)
-                to_process_old.append(original)
-
-        if to_process_new:
-            # Call the function with keyword arguments
-            func(new_records=to_process_new, old_records=to_process_old if any(to_process_old) else None)