django-bulk-hooks 0.1.50__tar.gz

django_bulk_hooks-0.1.50/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 konradbeck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_bulk_hooks-0.1.50/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.1
+Name: django-bulk-hooks
+Version: 0.1.50
+Summary: Lifecycle-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
+
+⚡ 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.50/README.md

@@ -0,0 +1,82 @@
+
+# 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.50/django_bulk_hooks/__init__.py

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

django_bulk_hooks-0.1.50/django_bulk_hooks/conditions.py

@@ -0,0 +1,158 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_dotted_attr(instance, dotted_path):
+    """
+    Recursively resolve a dotted attribute path, e.g., "type.category".
+    """
+    for attr in dotted_path.split("."):
+        if instance is None:
+            return None
+        instance = getattr(instance, attr, None)
+    return instance
+
+
+class HookCondition:
+    def check(self, instance, original_instance=None):
+        raise NotImplementedError
+
+    def __call__(self, instance, original_instance=None):
+        return self.check(instance, original_instance)
+
+    def __and__(self, other):
+        return AndCondition(self, other)
+
+    def __or__(self, other):
+        return OrCondition(self, other)
+
+    def __invert__(self):
+        return NotCondition(self)
+
+
+class WhenFieldValueIsNot(HookCondition):
+    def __init__(self, field, value, only_on_change=False):
+        self.field = field
+        self.value = value
+        self.only_on_change = only_on_change
+
+    def check(self, instance, original_instance=None):
+        current = resolve_dotted_attr(instance, self.field)
+        logger.debug(
+            "%s current=%r, original=%r",
+            self.field,
+            current,
+            resolve_dotted_attr(original_instance, self.field) if original_instance else None,
+        )
+        if self.only_on_change:
+            if original_instance is None:
+                return False
+            previous = resolve_dotted_attr(original_instance, self.field)
+            return previous == self.value and current != self.value
+        else:
+            return current != self.value
+
+
+class WhenFieldValueIs(HookCondition):
+    def __init__(self, field, value, only_on_change=False):
+        self.field = field
+        self.value = value
+        self.only_on_change = only_on_change
+
+    def check(self, instance, original_instance=None):
+        current = resolve_dotted_attr(instance, self.field)
+        logger.debug(
+            "%s current=%r, original=%r",
+            self.field,
+            current,
+            resolve_dotted_attr(original_instance, self.field) if original_instance else None,
+        )
+        if self.only_on_change:
+            if original_instance is None:
+                return False
+            previous = resolve_dotted_attr(original_instance, self.field)
+            return previous != self.value and current == self.value
+        else:
+            return current == self.value
+
+
+class WhenFieldHasChanged(HookCondition):
+    def __init__(self, field, has_changed=True):
+        self.field = field
+        self.has_changed = has_changed
+
+    def check(self, instance, original_instance=None):
+        if not original_instance:
+            return False
+        current = resolve_dotted_attr(instance, self.field)
+        previous = resolve_dotted_attr(original_instance, self.field)
+        return (current != previous) == self.has_changed
+
+
+class WhenFieldValueWas(HookCondition):
+    def __init__(self, field, value, only_on_change=False):
+        """
+        Check if a field's original value was `value`.
+        If only_on_change is True, only return True when the field has changed away from that value.
+        """
+        self.field = field
+        self.value = value
+        self.only_on_change = only_on_change
+
+    def check(self, instance, original_instance=None):
+        if original_instance is None:
+            return False
+        previous = resolve_dotted_attr(original_instance, self.field)
+        if self.only_on_change:
+            current = resolve_dotted_attr(instance, self.field)
+            return previous == self.value and current != self.value
+        else:
+            return previous == self.value
+
+
+class WhenFieldValueChangesTo(HookCondition):
+    def __init__(self, field, value):
+        """
+        Check if a field's value has changed to `value`.
+        Only returns True when original value != value and current value == value.
+        """
+        self.field = field
+        self.value = value
+
+    def check(self, instance, original_instance=None):
+        if original_instance is None:
+            return False
+        previous = resolve_dotted_attr(original_instance, self.field)
+        current = resolve_dotted_attr(instance, self.field)
+        return previous != self.value and current == self.value
+
+
+class AndCondition(HookCondition):
+    def __init__(self, cond1, cond2):
+        self.cond1 = cond1
+        self.cond2 = cond2
+
+    def check(self, instance, original_instance=None):
+        return self.cond1.check(instance, original_instance) and self.cond2.check(
+            instance, original_instance
+        )
+
+
+class OrCondition(HookCondition):
+    def __init__(self, cond1, cond2):
+        self.cond1 = cond1
+        self.cond2 = cond2
+
+    def check(self, instance, original_instance=None):
+        return self.cond1.check(instance, original_instance) or self.cond2.check(
+            instance, original_instance
+        )
+
+
+class NotCondition(HookCondition):
+    def __init__(self, cond):
+        self.cond = cond
+
+    def check(self, instance, original_instance=None):
+        return not self.cond.check(instance, original_instance)

django_bulk_hooks-0.1.50/django_bulk_hooks/constants.py

@@ -0,0 +1,6 @@
+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.50/django_bulk_hooks/context.py

@@ -0,0 +1,4 @@
+class TriggerContext:
+    def __init__(self, model_cls, metadata=None):
+        self.model_cls = model_cls
+        self.metadata = metadata or {}

django_bulk_hooks-0.1.50/django_bulk_hooks/decorators.py

@@ -0,0 +1,93 @@
+import inspect
+from functools import wraps
+
+from django.core.exceptions import FieldDoesNotExist
+from django_bulk_hooks.enums import DEFAULT_PRIORITY
+
+
+def hook(event, *, model, condition=None, priority=DEFAULT_PRIORITY):
+    """
+    Decorator to annotate a method with multiple hooks hook registrations.
+    If no priority is provided, uses Priority.NORMAL (50).
+    """
+
+    def decorator(fn):
+        if not hasattr(fn, "hooks_hooks"):
+            fn.hooks_hooks = []
+        fn.hooks_hooks.append((model, event, condition, priority))
+        return fn
+
+    return decorator
+
+
+def select_related(*related_fields):
+    """
+    Decorator that preloads related fields in-place on `new_records`, before the hook logic runs.
+
+    - Works with instance methods (resolves `self`)
+    - Avoids replacing model instances
+    - Populates Django's relation cache to avoid extra queries
+    """
+
+    def decorator(func):
+        sig = inspect.signature(func)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            bound = sig.bind_partial(*args, **kwargs)
+            bound.apply_defaults()
+
+            if "new_records" not in bound.arguments:
+                raise TypeError(
+                    "@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"@preload_related expects a list of model instances, got {type(new_records)}"
+                )
+
+            if not new_records:
+                return func(*args, **kwargs)
+
+            # In-place preload
+            model_cls = new_records[0].__class__
+            ids = [obj.pk for obj in new_records if obj.pk is not None]
+            if not ids:
+                return func(*args, **kwargs)
+
+            fetched = model_cls.objects.select_related(*related_fields).in_bulk(ids)
+
+            for obj in new_records:
+                preloaded = fetched.get(obj.pk)
+                if not preloaded:
+                    continue
+                for field in related_fields:
+                    if "." in field:
+                        raise ValueError(
+                            f"@preload_related does not support nested fields like '{field}'"
+                        )
+
+                    try:
+                        f = model_cls._meta.get_field(field)
+                        if not (
+                            f.is_relation and not f.many_to_many and not f.one_to_many
+                        ):
+                            continue
+                    except FieldDoesNotExist:
+                        continue
+
+                    try:
+                        rel_obj = getattr(preloaded, field)
+                        setattr(obj, field, rel_obj)
+                        obj._state.fields_cache[field] = rel_obj
+                    except AttributeError:
+                        pass
+
+            return func(*bound.args, **bound.kwargs)
+
+        return wrapper
+
+    return decorator

django_bulk_hooks-0.1.50/django_bulk_hooks/engine.py

@@ -0,0 +1,63 @@
+import logging
+
+from django_bulk_hooks.registry import get_hooks
+
+logger = logging.getLogger(__name__)
+
+
+def run(model_cls, event, new_instances, original_instances=None, ctx=None):
+    hooks = get_hooks(model_cls, event)
+
+    logger.debug(
+        "bulk_hooks.run: model=%s, event=%s, #new=%d, #original=%d",
+        model_cls.__name__,
+        event,
+        len(new_instances),
+        len(original_instances or []),
+    )
+
+    for handler_cls, method_name, condition, priority in hooks:
+        handler_instance = handler_cls()
+        func = getattr(handler_instance, method_name)
+
+        logger.debug(
+            "Executing hook %s for %s.%s with priority=%s",
+            func.__name__,
+            model_cls.__name__,
+            event,
+            priority,
+        )
+
+        to_process_new = []
+        to_process_old = []
+
+        for new, original in zip(
+            new_instances,
+            original_instances or [None] * len(new_instances),
+            strict=True,
+        ):
+            logger.debug(
+                "  considering instance: new=%r, original=%r",
+                new,
+                original,
+            )
+
+            if not condition or condition.check(new, original):
+                to_process_new.append(new)
+                to_process_old.append(original)
+                logger.debug("    -> will process (passed condition)")
+            else:
+                logger.debug("    -> skipped (condition returned False)")
+
+        if to_process_new:
+            logger.info(
+                "Calling %s on %d instance(s): %r",
+                func.__name__,
+                len(to_process_new),
+                to_process_new,
+            )
+
+            # Call the function with direct arguments
+            func(to_process_new, to_process_old if any(to_process_old) else None)
+        else:
+            logger.debug("No instances to process for hook %s", func.__name__)

django_bulk_hooks-0.1.50/django_bulk_hooks/enums.py

@@ -0,0 +1,17 @@
+from enum import IntEnum
+
+
+class Priority(IntEnum):
+    """
+    Named priorities for django-bulk-hooks hooks.
+    Replaces module-level constants with a clean IntEnum.
+    """
+
+    HIGHEST = 0  # runs first
+    HIGH = 25  # runs early
+    NORMAL = 50  # default ordering
+    LOW = 75  # runs late
+    LOWEST = 100  # runs last
+
+
+DEFAULT_PRIORITY = Priority.NORMAL

django_bulk_hooks-0.1.50/django_bulk_hooks/handler.py

@@ -0,0 +1,208 @@
+import logging
+
+from django.db import transaction
+from django_bulk_hooks.conditions import HookCondition
+from django_bulk_hooks.registry import get_hooks, register_hook
+
+logger = logging.getLogger(__name__)
+
+
+class TriggerHandlerMeta(type):
+    _registered = set()
+
+    def __new__(mcs, name, bases, namespace):
+        cls = super().__new__(mcs, name, bases, namespace)
+        for method_name, method in namespace.items():
+            if hasattr(method, "hooks_hooks"):
+                for model_cls, event, condition, priority in method.hooks_hooks:
+                    key = (model_cls, event, cls, method_name)
+                    if key in TriggerHandlerMeta._registered:
+                        logger.debug(
+                            "Skipping duplicate registration for %s.%s on %s.%s",
+                            cls.__name__,
+                            method_name,
+                            model_cls.__name__,
+                            event,
+                        )
+                    else:
+                        register_hook(
+                            model=model_cls,
+                            event=event,
+                            handler_cls=cls,
+                            method_name=method_name,
+                            condition=condition,
+                            priority=priority,
+                        )
+                        TriggerHandlerMeta._registered.add(key)
+                        logger.debug(
+                            "Registered hook %s.%s → %s.%s (cond=%r, prio=%s)",
+                            model_cls.__name__,
+                            event,
+                            cls.__name__,
+                            method_name,
+                            condition,
+                            priority,
+                        )
+        return cls
+
+
+class TriggerHandler(metaclass=TriggerHandlerMeta):
+    @classmethod
+    def handle(
+        cls,
+        event: str,
+        model: type,
+        *,
+        new_records: list = None,
+        old_records: list = None,
+        **kwargs,
+    ) -> None:
+        # Prepare hook list and log names
+        hooks = get_hooks(model, event)
+
+        # Sort hooks by priority (ascending: lower number = higher priority)
+        hooks = sorted(hooks, key=lambda x: x[3])
+
+        hook_names = [f"{h.__name__}.{m}" for h, m, _, _ in hooks]
+        logger.debug(
+            "Found %d hooks for %s.%s: %s",
+            len(hooks),
+            model.__name__,
+            event,
+            hook_names,
+        )
+
+        def _process():
+            # Ensure new_records is a list
+            new_records_local = new_records or []
+
+            # Normalize old_records: ensure list and pad with None
+            old_records_local = list(old_records) if old_records else []
+            if len(old_records_local) < len(new_records_local):
+                old_records_local += [None] * (
+                    len(new_records_local) - len(old_records_local)
+                )
+
+            logger.debug(
+                "ℹ️  bulk_hooks.handle() start: model=%s event=%s new_count=%d old_count=%d",
+                model.__name__,
+                event,
+                len(new_records_local),
+                len(old_records_local),
+            )
+
+            for handler_cls, method_name, condition, priority in hooks:
+                logger.debug(
+                    "→ evaluating hook %s.%s (cond=%r, prio=%s)",
+                    handler_cls.__name__,
+                    method_name,
+                    condition,
+                    priority,
+                )
+
+                # Evaluate condition
+                passed = True
+                if condition is not None:
+                    if isinstance(condition, HookCondition):
+                        cond_info = getattr(condition, "__dict__", str(condition))
+                        logger.debug(
+                            "   [cond-info] %s.%s → %r",
+                            handler_cls.__name__,
+                            method_name,
+                            cond_info,
+                        )
+
+                        checks = []
+                        for new, old in zip(new_records_local, old_records_local):
+                            field_name = getattr(condition, "field", None) or getattr(
+                                condition, "field_name", None
+                            )
+                            if field_name:
+                                actual_val = getattr(new, field_name, None)
+                                expected = getattr(condition, "value", None) or getattr(
+                                    condition, "value", None
+                                )
+                                logger.debug(
+                                    "   [field-lookup] %s.%s → field=%r actual=%r expected=%r",
+                                    handler_cls.__name__,
+                                    method_name,
+                                    field_name,
+                                    actual_val,
+                                    expected,
+                                )
+                            result = condition.check(new, old)
+                            checks.append(result)
+                            logger.debug(
+                                "   [cond-check] %s.%s → new=%r old=%r => %s",
+                                handler_cls.__name__,
+                                method_name,
+                                new,
+                                old,
+                                result,
+                            )
+                        passed = any(checks)
+                        logger.debug(
+                            "   [cond-summary] %s.%s any-passed=%s",
+                            handler_cls.__name__,
+                            method_name,
+                            passed,
+                        )
+                    else:
+                        # Legacy callable conditions
+                        passed = condition(
+                            new_records=new_records_local,
+                            old_records=old_records_local,
+                        )
+                        logger.debug(
+                            "   [legacy-cond] %s.%s → full-list => %s",
+                            handler_cls.__name__,
+                            method_name,
+                            passed,
+                        )
+
+                if not passed:
+                    logger.debug(
+                        "↳ skipping %s.%s (condition not met)",
+                        handler_cls.__name__,
+                        method_name,
+                    )
+                    continue
+
+                # Instantiate & invoke handler method
+                handler = handler_cls()
+                method = getattr(handler, method_name)
+                logger.info(
+                    "✨ invoking %s.%s on %d record(s)",
+                    handler_cls.__name__,
+                    method_name,
+                    len(new_records_local),
+                )
+                try:
+                    method(
+                        new_records=new_records_local,
+                        old_records=old_records_local,
+                        **kwargs,
+                    )
+                except Exception:
+                    logger.exception(
+                        "❌ exception in %s.%s",
+                        handler_cls.__name__,
+                        method_name,
+                    )
+
+            logger.debug(
+                "✔️  bulk_hooks.handle() complete for %s.%s",
+                model.__name__,
+                event,
+            )
+
+        # Defer if in atomic block and event is after_*
+        conn = transaction.get_connection()
+        if conn.in_atomic_block and event.startswith("after_"):
+            logger.debug(
+                "Deferring hook execution until after transaction commit for event '%s'",
+                event,
+            )
+            transaction.on_commit(_process)
+        else:
+            _process()

django_bulk_hooks-0.1.50/django_bulk_hooks/manager.py

@@ -0,0 +1,130 @@
+from django.db import models, transaction
+from django_bulk_hooks import engine
+from django_bulk_hooks.constants import (
+    AFTER_CREATE,
+    AFTER_DELETE,
+    AFTER_UPDATE,
+    BEFORE_CREATE,
+    BEFORE_DELETE,
+    BEFORE_UPDATE,
+)
+from django_bulk_hooks.context import TriggerContext
+from django_bulk_hooks.queryset import LifecycleQuerySet
+
+
+class BulkLifecycleManager(models.Manager):
+    CHUNK_SIZE = 200
+
+    def get_queryset(self):
+        return LifecycleQuerySet(self.model, using=self._db)
+
+    @transaction.atomic
+    def bulk_update(self, objs, fields, batch_size=None, bypass_hooks=False):
+        if not objs:
+            return []
+
+        model_cls = self.model
+
+        if any(not isinstance(obj, model_cls) for obj in objs):
+            raise TypeError(
+                f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
+            )
+
+        if not bypass_hooks:
+            originals = list(model_cls.objects.filter(pk__in=[obj.pk for obj in objs]))
+            ctx = TriggerContext(model_cls)
+            engine.run(model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx)
+
+        for i in range(0, len(objs), self.CHUNK_SIZE):
+            chunk = objs[i : i + self.CHUNK_SIZE]
+            super().bulk_update(chunk, fields, batch_size=batch_size)
+
+        if not bypass_hooks:
+            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
+
+        return objs
+
+    @transaction.atomic
+    def bulk_create(
+        self, objs, batch_size=None, ignore_conflicts=False, bypass_hooks=False
+    ):
+        model_cls = self.model
+
+        if any(not isinstance(obj, model_cls) for obj in objs):
+            raise TypeError(
+                f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
+            )
+
+        result = []
+
+        if not bypass_hooks:
+            ctx = TriggerContext(model_cls)
+            engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
+
+        for i in range(0, len(objs), self.CHUNK_SIZE):
+            chunk = objs[i : i + self.CHUNK_SIZE]
+            result.extend(
+                super().bulk_create(
+                    chunk, batch_size=batch_size, ignore_conflicts=ignore_conflicts
+                )
+            )
+
+        if not bypass_hooks:
+            engine.run(model_cls, AFTER_CREATE, result, ctx=ctx)
+
+        return result
+
+    @transaction.atomic
+    def bulk_delete(self, objs, batch_size=None, bypass_hooks=False):
+        if not objs:
+            return []
+
+        model_cls = self.model
+
+        if any(not isinstance(obj, model_cls) for obj in objs):
+            raise TypeError(
+                f"bulk_delete expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
+            )
+
+        ctx = TriggerContext(model_cls)
+
+        if not bypass_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:
+            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
+
+        return objs
+
+    @transaction.atomic
+    def update(self, **kwargs):
+        objs = list(self.all())
+        if not objs:
+            return 0
+        for key, value in kwargs.items():
+            for obj in objs:
+                setattr(obj, key, value)
+        self.bulk_update(objs, fields=list(kwargs.keys()))
+        return len(objs)
+
+    @transaction.atomic
+    def delete(self):
+        objs = list(self.all())
+        if not objs:
+            return 0
+        self.model.objects.bulk_delete(objs)
+        return len(objs)
+
+    @transaction.atomic
+    def save(self, obj):
+        if obj.pk:
+            self.bulk_update(
+                [obj],
+                fields=[field.name for field in obj._meta.fields if field.name != "id"],
+            )
+        else:
+            self.bulk_create([obj])
+        return obj

django_bulk_hooks-0.1.50/django_bulk_hooks/models.py

@@ -0,0 +1,25 @@
+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

django_bulk_hooks-0.1.50/django_bulk_hooks/priority.py

@@ -0,0 +1,16 @@
+from enum import IntEnum
+
+
+class Priority(IntEnum):
+    """
+    Named priorities for django-bulk-hooks hooks.
+
+    Lower values run earlier (higher priority).
+    Hooks are sorted in ascending order.
+    """
+
+    HIGHEST = 0  # runs first
+    HIGH = 25  # runs early
+    NORMAL = 50  # default ordering
+    LOW = 75  # runs later
+    LOWEST = 100  # runs last

django_bulk_hooks-0.1.50/django_bulk_hooks/queryset.py

@@ -0,0 +1,27 @@
+from django.db import models, transaction
+
+
+class LifecycleQuerySet(models.QuerySet):
+    @transaction.atomic
+    def delete(self):
+        objs = list(self)
+        if not objs:
+            return 0
+        return self.model.objects.bulk_delete(objs)
+
+    @transaction.atomic
+    def update(self, **kwargs):
+        instances = list(self)
+        if not instances:
+            return 0
+
+        for obj in instances:
+            for field, value in kwargs.items():
+                setattr(obj, field, value)
+
+        self.model.objects.bulk_update(
+            instances,
+            fields=list(kwargs.keys()),
+        )
+
+        return len(instances)

django_bulk_hooks-0.1.50/django_bulk_hooks/registry.py

@@ -0,0 +1,20 @@
+from collections.abc import Callable
+from typing import Union
+
+from django_bulk_hooks.priority 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), [])

django_bulk_hooks-0.1.50/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "django-bulk-hooks"
+version = "0.1.50"
+description = "Lifecycle-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"
+homepage = "https://github.com/AugendLimited/django-bulk-hooks"
+repository = "https://github.com/AugendLimited/django-bulk-hooks"
+keywords = ["django", "bulk", "hooks"]
+packages = [
+    { include = "django_bulk_hooks" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+Django = ">=4.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"