django-bulk-hooks 0.1.67__tar.gz → 0.1.69__tar.gz

django_bulk_hooks-0.1.69/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.1
+Name: django-bulk-hooks
+Version: 0.1.69
+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, 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 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 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
+```
+
+## 🧩 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.69/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, 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 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 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
+```
+
+## 🧩 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.69/django_bulk_hooks/__init__.py

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

{django_bulk_hooks-0.1.67 → django_bulk_hooks-0.1.69}/django_bulk_hooks/constants.py

@@ -4,3 +4,6 @@ BEFORE_UPDATE = "before_update"
 AFTER_UPDATE = "after_update"
 BEFORE_DELETE = "before_delete"
 AFTER_DELETE = "after_delete"
+VALIDATE_CREATE = "validate_create"
+VALIDATE_UPDATE = "validate_update"
+VALIDATE_DELETE = "validate_delete"

{django_bulk_hooks-0.1.67 → django_bulk_hooks-0.1.69}/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__)
@@ -21,6 +21,16 @@ def run(model_cls, event, new_instances, original_instances=None, ctx=None):
         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)

{django_bulk_hooks-0.1.67 → django_bulk_hooks-0.1.69}/django_bulk_hooks/handler.py

@@ -64,7 +64,7 @@ class HookContextState:
 Hook = HookContextState()
 
 
-class HookHandlerMeta(type):
+class HookMeta(type):
     _registered = set()
 
     def __new__(mcs, name, bases, namespace):
@@ -73,9 +73,9 @@ class HookHandlerMeta(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 HookHandlerMeta._registered:
+                    if key not in HookMeta._registered:
                         logger.info(
-                            "Registering hook via HookHandlerMeta: model=%s, event=%s, handler_cls=%s, method_name=%s",
+                            "Registering hook via HookMeta: model=%s, event=%s, handler_cls=%s, method_name=%s",
                             model_cls.__name__,
                             event,
                             cls.__name__,
@@ -89,11 +89,11 @@ class HookHandlerMeta(type):
                             condition=condition,
                             priority=priority,
                         )
-                        HookHandlerMeta._registered.add(key)
+                        HookMeta._registered.add(key)
         return cls
 
 
-class HookHandler(metaclass=HookHandlerMeta):
+class Hook(metaclass=HookMeta):
     @classmethod
     def handle(
         cls,

{django_bulk_hooks-0.1.67 → django_bulk_hooks-0.1.69}/django_bulk_hooks/manager.py

@@ -10,6 +10,9 @@ from django_bulk_hooks.constants import (
     BEFORE_CREATE,
     BEFORE_DELETE,
     BEFORE_UPDATE,
+    VALIDATE_CREATE,
+    VALIDATE_UPDATE,
+    VALIDATE_DELETE,
 )
 from django_bulk_hooks.context import HookContext
 from django_bulk_hooks.queryset import HookQuerySet
@@ -24,7 +27,7 @@ class BulkHookManager(models.Manager):
         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 []
 
@@ -38,6 +41,12 @@ class BulkHookManager(models.Manager):
         if not bypass_hooks:
             originals = list(model_cls.objects.filter(pk__in=[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
@@ -106,7 +115,7 @@ class BulkHookManager(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):
@@ -118,6 +127,12 @@ class BulkHookManager(models.Manager):
 
         if not bypass_hooks:
             ctx = HookContext(model_cls)
+            
+            # Run validation hooks first
+            if not bypass_validation:
+                engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
+            
+            # Then run business logic hooks
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
 
         for i in range(0, len(objs), self.CHUNK_SIZE):
@@ -130,7 +145,7 @@ class BulkHookManager(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 []
 
@@ -144,8 +159,14 @@ class BulkHookManager(models.Manager):
         ctx = HookContext(model_cls)
 
         if not bypass_hooks:
-            logger.info("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]

django_bulk_hooks-0.1.69/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.67 → django_bulk_hooks-0.1.69}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.67"
+version = "0.1.69"
 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.67/PKG-INFO

@@ -1,101 +0,0 @@
-Metadata-Version: 2.1
-Name: django-bulk-hooks
-Version: 0.1.67
-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.
-
-`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.
-
-## ✨ Features
-
-- Declarative hook system: `@hook(AFTER_UPDATE, condition=...)`
-- BEFORE/AFTER hooks for create, update, delete
-- Hook-aware manager that wraps Django's `bulk_` operations
-- Hook chaining, hook 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 BulkHookManager
-
-class Account(models.Model):
-    balance = models.DecimalField(max_digits=10, decimal_places=2)
-    objects = 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_objs):
-        print("Accounts updated:", [a.pk for a in new_objs])
-```
-
-## 🛠 Supported Hook 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:
-
-- Hooks that behave consistently across creates/updates/deletes
-- Scalable performance via chunking (default 200)
-- Support for `@hook` decorators and centralized hook classes
-
-## 📦 Usage in Views / Commands
-
-```python
-# Calls AFTER_UPDATE hooks automatically
-Account.objects.bulk_update(accounts, ['balance'])
-
-# Triggers BEFORE_CREATE and AFTER_CREATE hooks
-Account.objects.bulk_create(accounts)
-```
-
-## 🧩 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.67/README.md

@@ -1,81 +0,0 @@
-
-# django-bulk-hooks
-
-⚡ Bulk hooks for Django bulk operations.
-
-`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.
-
-## ✨ Features
-
-- Declarative hook system: `@hook(AFTER_UPDATE, condition=...)`
-- BEFORE/AFTER hooks for create, update, delete
-- Hook-aware manager that wraps Django's `bulk_` operations
-- Hook chaining, hook 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 BulkHookManager
-
-class Account(models.Model):
-    balance = models.DecimalField(max_digits=10, decimal_places=2)
-    objects = 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_objs):
-        print("Accounts updated:", [a.pk for a in new_objs])
-```
-
-## 🛠 Supported Hook 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:
-
-- Hooks that behave consistently across creates/updates/deletes
-- Scalable performance via chunking (default 200)
-- Support for `@hook` decorators and centralized hook classes
-
-## 📦 Usage in Views / Commands
-
-```python
-# Calls AFTER_UPDATE hooks automatically
-Account.objects.bulk_update(accounts, ['balance'])
-
-# Triggers BEFORE_CREATE and AFTER_CREATE hooks
-Account.objects.bulk_create(accounts)
-```
-
-## 🧩 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.67/django_bulk_hooks/__init__.py

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

django_bulk_hooks-0.1.67/django_bulk_hooks/models.py

@@ -1,26 +0,0 @@
-from django.db import models, transaction
-
-from django_bulk_hooks.manager import BulkHookManager
-
-
-class HookModelMixin(models.Model):
-    objects = BulkHookManager()
-
-    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