django-bulk-hooks 0.1.66__tar.gz → 0.1.68__tar.gz

django_bulk_hooks-0.1.68/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.1
+Name: django-bulk-hooks
+Version: 0.1.68
+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
+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 (>=4.0)
+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, HookHandler
+from django_bulk_hooks.conditions import WhenFieldHasChanged
+from .models import Account
+
+class AccountHookHandler(HookHandler):
+    @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 triggers hooks for individual model operations:
+
+```python
+# These will trigger BEFORE_CREATE and AFTER_CREATE hooks
+account = Account.objects.create(balance=100.00)
+account.save()  # for new instances
+
+# These will trigger BEFORE_UPDATE and AFTER_UPDATE hooks
+account.balance = 200.00
+account.save()  # for existing instances
+
+# This will trigger BEFORE_DELETE and AFTER_DELETE hooks
+account.delete()
+```
+
+### Bulk Operations
+
+Bulk operations also trigger the same hooks:
+
+```python
+# Bulk create - triggers BEFORE_CREATE and AFTER_CREATE hooks
+accounts = [
+    Account(balance=100.00),
+    Account(balance=200.00),
+]
+Account.objects.bulk_create(accounts)
+
+# Bulk update - triggers BEFORE_UPDATE and AFTER_UPDATE hooks
+for account in accounts:
+    account.balance *= 1.1
+Account.objects.bulk_update(accounts, ['balance'])
+
+# Bulk delete - triggers BEFORE_DELETE and AFTER_DELETE hooks
+Account.objects.bulk_delete(accounts)
+```
+
+### Queryset Operations
+
+Queryset operations are also supported:
+
+```python
+# Queryset update - triggers BEFORE_UPDATE and AFTER_UPDATE hooks
+Account.objects.update(balance=0.00)
+
+# Queryset delete - triggers BEFORE_DELETE and AFTER_DELETE hooks
+Account.objects.delete()
+```
+
+## 🧠 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 triggering for admin operations and other Django features
+
+## 📦 Usage Examples
+
+### Individual Model Operations
+
+```python
+# These automatically trigger hooks
+account = Account.objects.create(balance=100.00)
+account.balance = 200.00
+account.save()
+account.delete()
+```
+
+### Bulk Operations
+
+```python
+# These also trigger hooks
+Account.objects.bulk_create(accounts)
+Account.objects.bulk_update(accounts, ['balance'])
+Account.objects.bulk_delete(accounts)
+```
+
+### Advanced Hook Usage
+
+```python
+class AdvancedAccountHandler(HookHandler):
+    @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
+```
+
+## 🧩 Integration with Queryable Properties
+
+You can extend from `BulkHookManager` to support formula fields or property querying.
+
+```python
+class MyManager(BulkHookManager, QueryablePropertiesManager):
+    pass
+```
+
+## 📝 License
+
+MIT © 2024 Augend / Konrad Beck
+

django_bulk_hooks-0.1.68/README.md

@@ -0,0 +1,175 @@
+
+# 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, HookHandler
+from django_bulk_hooks.conditions import WhenFieldHasChanged
+from .models import Account
+
+class AccountHookHandler(HookHandler):
+    @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 triggers hooks for individual model operations:
+
+```python
+# These will trigger BEFORE_CREATE and AFTER_CREATE hooks
+account = Account.objects.create(balance=100.00)
+account.save()  # for new instances
+
+# These will trigger BEFORE_UPDATE and AFTER_UPDATE hooks
+account.balance = 200.00
+account.save()  # for existing instances
+
+# This will trigger BEFORE_DELETE and AFTER_DELETE hooks
+account.delete()
+```
+
+### Bulk Operations
+
+Bulk operations also trigger the same hooks:
+
+```python
+# Bulk create - triggers BEFORE_CREATE and AFTER_CREATE hooks
+accounts = [
+    Account(balance=100.00),
+    Account(balance=200.00),
+]
+Account.objects.bulk_create(accounts)
+
+# Bulk update - triggers BEFORE_UPDATE and AFTER_UPDATE hooks
+for account in accounts:
+    account.balance *= 1.1
+Account.objects.bulk_update(accounts, ['balance'])
+
+# Bulk delete - triggers BEFORE_DELETE and AFTER_DELETE hooks
+Account.objects.bulk_delete(accounts)
+```
+
+### Queryset Operations
+
+Queryset operations are also supported:
+
+```python
+# Queryset update - triggers BEFORE_UPDATE and AFTER_UPDATE hooks
+Account.objects.update(balance=0.00)
+
+# Queryset delete - triggers BEFORE_DELETE and AFTER_DELETE hooks
+Account.objects.delete()
+```
+
+## 🧠 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 triggering for admin operations and other Django features
+
+## 📦 Usage Examples
+
+### Individual Model Operations
+
+```python
+# These automatically trigger hooks
+account = Account.objects.create(balance=100.00)
+account.balance = 200.00
+account.save()
+account.delete()
+```
+
+### Bulk Operations
+
+```python
+# These also trigger hooks
+Account.objects.bulk_create(accounts)
+Account.objects.bulk_update(accounts, ['balance'])
+Account.objects.bulk_delete(accounts)
+```
+
+### Advanced Hook Usage
+
+```python
+class AdvancedAccountHandler(HookHandler):
+    @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
+```
+
+## 🧩 Integration with Queryable Properties
+
+You can extend from `BulkHookManager` to support formula fields or property querying.
+
+```python
+class MyManager(BulkHookManager, QueryablePropertiesManager):
+    pass
+```
+
+## 📝 License
+
+MIT © 2024 Augend / Konrad Beck

django_bulk_hooks-0.1.68/django_bulk_hooks/__init__.py

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

django_bulk_hooks-0.1.68/django_bulk_hooks/constants.py

@@ -0,0 +1,11 @@
+BEFORE_CREATE = "before_create"
+AFTER_CREATE = "after_create"
+BEFORE_UPDATE = "before_update"
+AFTER_UPDATE = "after_update"
+BEFORE_DELETE = "before_delete"
+AFTER_DELETE = "after_delete"
+
+# Validation constants - run during clean() for admin/form validation
+VALIDATE_CREATE = "validate_create"
+VALIDATE_UPDATE = "validate_update"
+VALIDATE_DELETE = "validate_delete"

{django_bulk_hooks-0.1.66 → django_bulk_hooks-0.1.68}/django_bulk_hooks/context.py

@@ -1,16 +1,16 @@
-import threading
-from collections import deque
-
-_hook_context = threading.local()
-
-
-def get_hook_queue():
-    if not hasattr(_hook_context, "queue"):
-        _hook_context.queue = deque()
-    return _hook_context.queue
-
-
-class TriggerContext:
-    def __init__(self, model_cls, metadata=None):
-        self.model_cls = model_cls
-        self.metadata = metadata or {}
+import threading
+from collections import deque
+
+_hook_context = threading.local()
+
+
+def get_hook_queue():
+    if not hasattr(_hook_context, "queue"):
+        _hook_context.queue = deque()
+    return _hook_context.queue
+
+
+class HookContext:
+    def __init__(self, model_cls, metadata=None):
+        self.model_cls = model_cls
+        self.metadata = metadata or {}

{django_bulk_hooks-0.1.66 → django_bulk_hooks-0.1.68}/django_bulk_hooks/engine.py

@@ -1,5 +1,5 @@
 import logging
-
+from django.core.exceptions import ValidationError
 from django_bulk_hooks.registry import get_hooks
 
 logger = logging.getLogger(__name__)
@@ -8,19 +8,34 @@ logger = logging.getLogger(__name__)
 def run(model_cls, event, new_instances, original_instances=None, ctx=None):
     hooks = get_hooks(model_cls, event)
 
-    logger.debug(
-        "Executing engine.run: model=%s, event=%s, #new_instances=%d, #original_instances=%d",
+    logger.info(
+        "Executing engine.run: model=%s, event=%s, #new_instances=%d, #original_instances=%d, #hooks=%d",
         model_cls.__name__,
         event,
         len(new_instances),
         len(original_instances or []),
+        len(hooks),
     )
 
+    if not hooks:
+        logger.info("No hooks found for model=%s, event=%s", model_cls.__name__, event)
+        return
+
+    # For BEFORE_* events, run model.clean() first for validation
+    if event.startswith("before_"):
+        logger.debug("Running model.clean() for %d instances", len(new_instances))
+        for instance in new_instances:
+            try:
+                instance.clean()
+            except ValidationError as e:
+                logger.error("Validation failed 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)
 
-        logger.debug(
+        logger.info(
             "Executing hook %s for %s.%s with priority=%s",
             func.__name__,
             model_cls.__name__,

{django_bulk_hooks-0.1.66 → django_bulk_hooks-0.1.68}/django_bulk_hooks/handler.py

@@ -3,12 +3,14 @@ import threading
 from collections import deque
 
 from django.db import transaction
+
 from django_bulk_hooks.registry import get_hooks, register_hook
 
 logger = logging.getLogger(__name__)
 
-# Thread-local hook context and trigger state
-class TriggerVars(threading.local):
+
+# Thread-local hook context and hook state
+class HookVars(threading.local):
     def __init__(self):
         self.new = None
         self.old = None
@@ -16,48 +18,53 @@ class TriggerVars(threading.local):
         self.model = None
         self.depth = 0
 
-trigger = TriggerVars()
+
+hook_vars = HookVars()
 
 # Hook queue per thread
 _hook_context = threading.local()
 
+
 def get_hook_queue():
     if not hasattr(_hook_context, "queue"):
         _hook_context.queue = deque()
     return _hook_context.queue
 
-class TriggerContextState:
+
+class HookContextState:
     @property
     def is_before(self):
-        return trigger.event.startswith("before_") if trigger.event else False
+        return hook_vars.event.startswith("before_") if hook_vars.event else False
 
     @property
     def is_after(self):
-        return trigger.event.startswith("after_") if trigger.event else False
+        return hook_vars.event.startswith("after_") if hook_vars.event else False
 
     @property
     def is_create(self):
-        return "create" in trigger.event if trigger.event else False
+        return "create" in hook_vars.event if hook_vars.event else False
 
     @property
     def is_update(self):
-        return "update" in trigger.event if trigger.event else False
+        return "update" in hook_vars.event if hook_vars.event else False
 
     @property
     def new(self):
-        return trigger.new
+        return hook_vars.new
 
     @property
     def old(self):
-        return trigger.old
+        return hook_vars.old
 
     @property
     def model(self):
-        return trigger.model
+        return hook_vars.model
 
-Trigger = TriggerContextState()
 
-class TriggerHandlerMeta(type):
+Hook = HookContextState()
+
+
+class HookHandlerMeta(type):
     _registered = set()
 
     def __new__(mcs, name, bases, namespace):
@@ -66,7 +73,14 @@ class TriggerHandlerMeta(type):
             if hasattr(method, "hooks_hooks"):
                 for model_cls, event, condition, priority in method.hooks_hooks:
                     key = (model_cls, event, cls, method_name)
-                    if key not in TriggerHandlerMeta._registered:
+                    if key not in HookHandlerMeta._registered:
+                        logger.info(
+                            "Registering hook via HookHandlerMeta: model=%s, event=%s, handler_cls=%s, method_name=%s",
+                            model_cls.__name__,
+                            event,
+                            cls.__name__,
+                            method_name,
+                        )
                         register_hook(
                             model=model_cls,
                             event=event,
@@ -75,10 +89,11 @@ class TriggerHandlerMeta(type):
                             condition=condition,
                             priority=priority,
                         )
-                        TriggerHandlerMeta._registered.add(key)
+                        HookHandlerMeta._registered.add(key)
         return cls
 
-class TriggerHandler(metaclass=TriggerHandlerMeta):
+
+class HookHandler(metaclass=HookHandlerMeta):
     @classmethod
     def handle(
         cls,
@@ -109,11 +124,11 @@ class TriggerHandler(metaclass=TriggerHandlerMeta):
         old_records,
         **kwargs,
     ):
-        trigger.depth += 1
-        trigger.new = new_records
-        trigger.old = old_records
-        trigger.event = event
-        trigger.model = model
+        hook_vars.depth += 1
+        hook_vars.new = new_records
+        hook_vars.old = old_records
+        hook_vars.event = event
+        hook_vars.model = model
 
         hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
         logger.debug("Processing %d hooks for %s.%s", len(hooks), model.__name__, event)
@@ -126,14 +141,21 @@ class TriggerHandler(metaclass=TriggerHandlerMeta):
 
             for handler_cls, method_name, condition, priority in hooks:
                 if condition is not None:
-                    checks = [condition.check(n, o) for n, o in zip(new_local, old_local)]
+                    checks = [
+                        condition.check(n, o) for n, o in zip(new_local, old_local)
+                    ]
                     if not any(checks):
                         continue
 
                 handler = handler_cls()
                 method = getattr(handler, method_name)
 
-                logger.info("Running hook %s.%s on %d items", handler_cls.__name__, method_name, len(new_local))
+                logger.info(
+                    "Running hook %s.%s on %d items",
+                    handler_cls.__name__,
+                    method_name,
+                    len(new_local),
+                )
                 try:
                     method(
                         new_records=new_local,
@@ -141,7 +163,9 @@ class TriggerHandler(metaclass=TriggerHandlerMeta):
                         **kwargs,
                     )
                 except Exception:
-                    logger.exception("Error in hook %s.%s", handler_cls.__name__, method_name)
+                    logger.exception(
+                        "Error in hook %s.%s", handler_cls.__name__, method_name
+                    )
 
         conn = transaction.get_connection()
         try:
@@ -150,8 +174,8 @@ class TriggerHandler(metaclass=TriggerHandlerMeta):
             else:
                 _execute()
         finally:
-            trigger.new = None
-            trigger.old = None
-            trigger.event = None
-            trigger.model = None
-            trigger.depth -= 1
+            hook_vars.new = None
+            hook_vars.old = None
+            hook_vars.event = None
+            hook_vars.model = None
+            hook_vars.depth -= 1

{django_bulk_hooks-0.1.66 → django_bulk_hooks-0.1.68}/django_bulk_hooks/manager.py

@@ -1,4 +1,7 @@
+import logging
+
 from django.db import models, transaction
+
 from django_bulk_hooks import engine
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
@@ -7,22 +10,24 @@ from django_bulk_hooks.constants import (
     BEFORE_CREATE,
     BEFORE_DELETE,
     BEFORE_UPDATE,
+    VALIDATE_CREATE,
+    VALIDATE_UPDATE,
+    VALIDATE_DELETE,
 )
-from django_bulk_hooks.context import TriggerContext
-from django_bulk_hooks.queryset import LifecycleQuerySet
-import logging
+from django_bulk_hooks.context import HookContext
+from django_bulk_hooks.queryset import HookQuerySet
 
 logger = logging.getLogger(__name__)
 
 
-class BulkLifecycleManager(models.Manager):
+class BulkHookManager(models.Manager):
     CHUNK_SIZE = 200
 
     def get_queryset(self):
-        return LifecycleQuerySet(self.model, using=self._db)
+        return HookQuerySet(self.model, using=self._db)
 
     @transaction.atomic
-    def bulk_update(self, objs, fields, bypass_hooks=False, **kwargs):
+    def bulk_update(self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs):
         if not objs:
             return []
 
@@ -35,7 +40,13 @@ class BulkLifecycleManager(models.Manager):
 
         if not bypass_hooks:
             originals = list(model_cls.objects.filter(pk__in=[obj.pk for obj in objs]))
-            ctx = TriggerContext(model_cls)
+            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
@@ -104,7 +115,7 @@ class BulkLifecycleManager(models.Manager):
         return modified_fields
 
     @transaction.atomic
-    def bulk_create(self, objs, bypass_hooks=False, **kwargs):
+    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):
@@ -115,7 +126,13 @@ class BulkLifecycleManager(models.Manager):
         result = []
 
         if not bypass_hooks:
-            ctx = TriggerContext(model_cls)
+            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):
@@ -128,7 +145,7 @@ class BulkLifecycleManager(models.Manager):
         return result
 
     @transaction.atomic
-    def bulk_delete(self, objs, batch_size=None, bypass_hooks=False):
+    def bulk_delete(self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False):
         if not objs:
             return []
 
@@ -139,17 +156,25 @@ class BulkLifecycleManager(models.Manager):
                 f"bulk_delete expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        ctx = TriggerContext(model_cls)
+        ctx = HookContext(model_cls)
 
         if not bypass_hooks:
-            logger.debug("Executing BEFORE_DELETE hooks for %s", model_cls.__name__)
+            logger.info("Executing hooks for %s", model_cls.__name__)
+            logger.info("Number of objects to delete: %d", len(objs))
+            
+            # 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]
         model_cls.objects.filter(pk__in=pks).delete()
 
         if not bypass_hooks:
-            logger.debug("Executing AFTER_DELETE hooks for %s", model_cls.__name__)
+            logger.info("Executing AFTER_DELETE hooks for %s", model_cls.__name__)
+            logger.info("Number of objects deleted: %d", len(objs))
             engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
 
         return objs

django_bulk_hooks-0.1.68/django_bulk_hooks/models.py

@@ -0,0 +1,95 @@
+from django.db import models, transaction
+
+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.engine import run
+from django_bulk_hooks.manager import BulkHookManager
+
+
+class HookModelMixin(models.Model):
+    objects = BulkHookManager()
+
+    class Meta:
+        abstract = True
+
+    def clean(self):
+        """
+        Override clean() to trigger validation hooks.
+        This ensures that when Django calls clean() (like in admin forms),
+        it triggers the VALIDATE_* hooks for validation only.
+        """
+        super().clean()
+
+        # Determine if this is a create or update operation
+        is_create = self.pk is None
+
+        if is_create:
+            # For create operations, run VALIDATE_CREATE hooks for validation
+            ctx = HookContext(self.__class__)
+            run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
+        else:
+            # For update operations, run VALIDATE_UPDATE hooks for validation
+            try:
+                old_instance = self.__class__.objects.get(pk=self.pk)
+                ctx = HookContext(self.__class__)
+                run(self.__class__, VALIDATE_UPDATE, [self], [old_instance], ctx=ctx)
+            except self.__class__.DoesNotExist:
+                # If the old instance doesn't exist, treat as create
+                ctx = HookContext(self.__class__)
+                run(self.__class__, VALIDATE_CREATE, [self], ctx=ctx)
+
+    def save(self, *args, **kwargs):
+        is_create = self.pk is None
+
+        if is_create:
+            # For create operations, we don't have old records
+            ctx = HookContext(self.__class__)
+            run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
+
+            super().save(*args, **kwargs)
+
+            run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
+        else:
+            # For update operations, we need to get the old record
+            try:
+                old_instance = self.__class__.objects.get(pk=self.pk)
+                ctx = HookContext(self.__class__)
+                run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
+
+                super().save(*args, **kwargs)
+
+                run(self.__class__, AFTER_UPDATE, [self], [old_instance], ctx=ctx)
+            except self.__class__.DoesNotExist:
+                # If the old instance doesn't exist, treat as create
+                ctx = HookContext(self.__class__)
+                run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
+
+                super().save(*args, **kwargs)
+
+                run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
+
+        return self
+
+    def delete(self, *args, **kwargs):
+        ctx = HookContext(self.__class__)
+
+        # Run validation hooks first
+        run(self.__class__, VALIDATE_DELETE, [self], ctx=ctx)
+
+        # Then run business logic hooks
+        run(self.__class__, BEFORE_DELETE, [self], ctx=ctx)
+
+        result = super().delete(*args, **kwargs)
+
+        run(self.__class__, AFTER_DELETE, [self], ctx=ctx)
+        return result

{django_bulk_hooks-0.1.66 → django_bulk_hooks-0.1.68}/django_bulk_hooks/queryset.py

@@ -1,7 +1,7 @@
 from django.db import models, transaction
 
 
-class LifecycleQuerySet(models.QuerySet):
+class HookQuerySet(models.QuerySet):
     @transaction.atomic
     def delete(self):
         objs = list(self)
@@ -29,9 +29,9 @@ class LifecycleQuerySet(models.QuerySet):
 
         # Run BEFORE_UPDATE hooks
         from django_bulk_hooks import engine
-        from django_bulk_hooks.context import TriggerContext
+        from django_bulk_hooks.context import HookContext
 
-        ctx = TriggerContext(model_cls)
+        ctx = HookContext(model_cls)
         engine.run(model_cls, "before_update", instances, originals, ctx=ctx)
 
         # Use Django's built-in update logic directly

{django_bulk_hooks-0.1.66 → django_bulk_hooks-0.1.68}/django_bulk_hooks/registry.py

@@ -1,10 +1,9 @@
+import logging
 from collections.abc import Callable
 from typing import Union
 
 from django_bulk_hooks.priority import Priority
 
-import logging
-
 logger = logging.getLogger(__name__)
 
 _hooks: dict[tuple[type, str], list[tuple[type, str, Callable, int]]] = {}
@@ -18,7 +17,7 @@ def register_hook(
     hooks.append((handler_cls, method_name, condition, priority))
     # keep sorted by priority
     hooks.sort(key=lambda x: x[3])
-    logger.debug(
+    logger.info(
         "Registering hook: model=%s, event=%s, handler_cls=%s, method_name=%s, condition=%s, priority=%s",
         model.__name__,
         event,
@@ -30,10 +29,17 @@ def register_hook(
 
 
 def get_hooks(model, event):
-    logger.debug(
+    hooks = _hooks.get((model, event), [])
+    logger.info(
         "Retrieving hooks: model=%s, event=%s, hooks_found=%d",
         model.__name__,
         event,
-        len(_hooks.get((model, event), [])),
+        len(hooks),
     )
-    return _hooks.get((model, event), [])
+    return hooks
+
+
+def list_all_hooks():
+    """Debug function to list all registered hooks"""
+    logger.debug("All registered hooks: %s", _hooks)
+    return _hooks

{django_bulk_hooks-0.1.66 → django_bulk_hooks-0.1.68}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.66"
-description = "Lifecycle-style hooks for Django bulk operations like bulk_create and bulk_update."
+version = "0.1.68"
+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"
 license = "MIT"

django_bulk_hooks-0.1.66/PKG-INFO

@@ -1,102 +0,0 @@
-Metadata-Version: 2.3
-Name: django-bulk-hooks
-Version: 0.1.66
-Summary: Lifecycle-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 (>=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
-
-
-# django-bulk-hooks
-
-⚡ Salesforce-style hooks hooks for Django bulk operations.
-
-`django-bulk-hooks` brings a declarative, trigger-like experience to Django's `bulk_create`, `bulk_update`, and `bulk_delete` — including support for `BEFORE_` and `AFTER_` hooks, conditions, batching, and transactional safety.
-
-## ✨ Features
-
-- Declarative hook system: `@hook(AFTER_UPDATE, condition=...)`
-- BEFORE/AFTER hooks for create, update, delete
-- Salesforce-style semantics with full batch support
-- Lifecycle-aware manager that wraps Django’s `bulk_` operations
-- Hook chaining, trigger deduplication, and atomicity
-- Class-based hook handlers with DI support
-
-## 🚀 Quickstart
-
-```bash
-pip install django-bulk-hooks
-```
-
-### Define Your Model
-
-```python
-from django.db import models
-from django_bulk_hooks.manager import BulkLifecycleManager
-
-class Account(models.Model):
-    balance = models.DecimalField(max_digits=10, decimal_places=2)
-    objects = BulkLifecycleManager()
-```
-
-### Create a Trigger Handler
-
-```python
-from django_bulk_hooks import hook, AFTER_UPDATE, TriggerHandler
-from django_bulk_hooks.conditions import WhenFieldHasChanged
-from .models import Account
-
-class AccountTriggerHandler(TriggerHandler):
-    @hook(AFTER_UPDATE, model=Account, condition=WhenFieldHasChanged("balance"))
-    def log_balance_change(self, new_objs):
-        print("Accounts updated:", [a.pk for a in new_objs])
-```
-
-## 🛠 Supported Lifecycle Events
-
-- `BEFORE_CREATE`, `AFTER_CREATE`
-- `BEFORE_UPDATE`, `AFTER_UPDATE`
-- `BEFORE_DELETE`, `AFTER_DELETE`
-
-## 🧠 Why?
-
-Django’s `bulk_` methods bypass signals and `save()`. This package fills that gap with:
-
-- Triggers that behave consistently across creates/updates/deletes
-- Scalable performance via chunking (default 200)
-- Support for `@hook` decorators and centralized trigger classes
-
-## 📦 Usage in Views / Commands
-
-```python
-# Calls AFTER_UPDATE hooks automatically
-Account.objects.bulk_update(accounts, ['balance'])
-
-# Triggers BEFORE_CREATE and AFTER_CREATE
-Account.objects.bulk_create(accounts)
-```
-
-## 🧩 Integration with Queryable Properties
-
-You can extend from `BulkLifecycleManager` to support formula fields or property querying.
-
-```python
-class MyManager(BulkLifecycleManager, QueryablePropertiesManager):
-    pass
-```
-
-## 📝 License
-
-MIT © 2024 Augend / Konrad Beck
-

django_bulk_hooks-0.1.66/README.md

@@ -1,82 +0,0 @@
-
-# django-bulk-hooks
-
-⚡ Salesforce-style hooks hooks for Django bulk operations.
-
-`django-bulk-hooks` brings a declarative, trigger-like experience to Django's `bulk_create`, `bulk_update`, and `bulk_delete` — including support for `BEFORE_` and `AFTER_` hooks, conditions, batching, and transactional safety.
-
-## ✨ Features
-
-- Declarative hook system: `@hook(AFTER_UPDATE, condition=...)`
-- BEFORE/AFTER hooks for create, update, delete
-- Salesforce-style semantics with full batch support
-- Lifecycle-aware manager that wraps Django’s `bulk_` operations
-- Hook chaining, trigger deduplication, and atomicity
-- Class-based hook handlers with DI support
-
-## 🚀 Quickstart
-
-```bash
-pip install django-bulk-hooks
-```
-
-### Define Your Model
-
-```python
-from django.db import models
-from django_bulk_hooks.manager import BulkLifecycleManager
-
-class Account(models.Model):
-    balance = models.DecimalField(max_digits=10, decimal_places=2)
-    objects = BulkLifecycleManager()
-```
-
-### Create a Trigger Handler
-
-```python
-from django_bulk_hooks import hook, AFTER_UPDATE, TriggerHandler
-from django_bulk_hooks.conditions import WhenFieldHasChanged
-from .models import Account
-
-class AccountTriggerHandler(TriggerHandler):
-    @hook(AFTER_UPDATE, model=Account, condition=WhenFieldHasChanged("balance"))
-    def log_balance_change(self, new_objs):
-        print("Accounts updated:", [a.pk for a in new_objs])
-```
-
-## 🛠 Supported Lifecycle Events
-
-- `BEFORE_CREATE`, `AFTER_CREATE`
-- `BEFORE_UPDATE`, `AFTER_UPDATE`
-- `BEFORE_DELETE`, `AFTER_DELETE`
-
-## 🧠 Why?
-
-Django’s `bulk_` methods bypass signals and `save()`. This package fills that gap with:
-
-- Triggers that behave consistently across creates/updates/deletes
-- Scalable performance via chunking (default 200)
-- Support for `@hook` decorators and centralized trigger classes
-
-## 📦 Usage in Views / Commands
-
-```python
-# Calls AFTER_UPDATE hooks automatically
-Account.objects.bulk_update(accounts, ['balance'])
-
-# Triggers BEFORE_CREATE and AFTER_CREATE
-Account.objects.bulk_create(accounts)
-```
-
-## 🧩 Integration with Queryable Properties
-
-You can extend from `BulkLifecycleManager` to support formula fields or property querying.
-
-```python
-class MyManager(BulkLifecycleManager, QueryablePropertiesManager):
-    pass
-```
-
-## 📝 License
-
-MIT © 2024 Augend / Konrad Beck

django_bulk_hooks-0.1.66/django_bulk_hooks/__init__.py

@@ -1,3 +0,0 @@
-from django_bulk_hooks.manager import BulkLifecycleManager
-
-__all__ = ["BulkLifecycleManager"]

django_bulk_hooks-0.1.66/django_bulk_hooks/constants.py

@@ -1,6 +0,0 @@
-BEFORE_CREATE = "before_create"
-AFTER_CREATE = "after_create"
-BEFORE_UPDATE = "before_update"
-AFTER_UPDATE = "after_update"
-BEFORE_DELETE = "before_delete"
-AFTER_DELETE = "after_delete"

django_bulk_hooks-0.1.66/django_bulk_hooks/models.py

@@ -1,25 +0,0 @@
-from django.db import models, transaction
-from django_bulk_hooks.manager import BulkLifecycleManager
-
-
-class LifecycleModelMixin(models.Model):
-    objects = BulkLifecycleManager()
-
-    class Meta:
-        abstract = True
-
-    def delete(self, *args, **kwargs):
-        self.before_delete()
-
-        with transaction.atomic():
-            result = super().delete(*args, **kwargs)
-
-        self.after_delete()
-
-        return result
-
-    def before_delete(self):
-        pass
-
-    def after_delete(self):
-        pass