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

{django_bulk_hooks-0.1.65 → django_bulk_hooks-0.1.67}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.65
-Summary: Lifecycle-style hooks for Django bulk operations like bulk_create and bulk_update.
+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
@@ -13,24 +14,22 @@ 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.
+⚡ Bulk 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.
+`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
-- Salesforce-style semantics with full batch support
-- Lifecycle-aware manager that wraps Django’s `bulk_` operations
-- Hook chaining, trigger deduplication, and atomicity
+- Hook-aware manager that wraps Django's `bulk_` operations
+- Hook chaining, hook deduplication, and atomicity
 - Class-based hook handlers with DI support
 
 ## 🚀 Quickstart
@@ -43,27 +42,27 @@ pip install django-bulk-hooks
 
 ```python
 from django.db import models
-from django_bulk_hooks.manager import BulkLifecycleManager
+from django_bulk_hooks.manager import BulkHookManager
 
 class Account(models.Model):
     balance = models.DecimalField(max_digits=10, decimal_places=2)
-    objects = BulkLifecycleManager()
+    objects = BulkHookManager()
 ```
 
-### Create a Trigger Handler
+### Create a Hook Handler
 
 ```python
-from django_bulk_hooks import hook, AFTER_UPDATE, TriggerHandler
+from django_bulk_hooks import hook, AFTER_UPDATE, HookHandler
 from django_bulk_hooks.conditions import WhenFieldHasChanged
 from .models import Account
 
-class AccountTriggerHandler(TriggerHandler):
+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 Lifecycle Events
+## 🛠 Supported Hook Events
 
 - `BEFORE_CREATE`, `AFTER_CREATE`
 - `BEFORE_UPDATE`, `AFTER_UPDATE`
@@ -71,11 +70,11 @@ class AccountTriggerHandler(TriggerHandler):
 
 ## 🧠 Why?
 
-Django’s `bulk_` methods bypass signals and `save()`. This package fills that gap with:
+Django's `bulk_` methods bypass signals and `save()`. This package fills that gap with:
 
-- Triggers that behave consistently across creates/updates/deletes
+- Hooks that behave consistently across creates/updates/deletes
 - Scalable performance via chunking (default 200)
-- Support for `@hook` decorators and centralized trigger classes
+- Support for `@hook` decorators and centralized hook classes
 
 ## 📦 Usage in Views / Commands
 
@@ -83,16 +82,16 @@ Django’s `bulk_` methods bypass signals and `save()`. This package fills that
 # Calls AFTER_UPDATE hooks automatically
 Account.objects.bulk_update(accounts, ['balance'])
 
-# Triggers BEFORE_CREATE and AFTER_CREATE
+# Triggers BEFORE_CREATE and AFTER_CREATE hooks
 Account.objects.bulk_create(accounts)
 ```
 
 ## 🧩 Integration with Queryable Properties
 
-You can extend from `BulkLifecycleManager` to support formula fields or property querying.
+You can extend from `BulkHookManager` to support formula fields or property querying.
 
 ```python
-class MyManager(BulkLifecycleManager, QueryablePropertiesManager):
+class MyManager(BulkHookManager, QueryablePropertiesManager):
     pass
 ```
 

django_bulk_hooks-0.1.67/README.md

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

@@ -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.65 → django_bulk_hooks-0.1.67}/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.65 → django_bulk_hooks-0.1.67}/django_bulk_hooks/engine.py

@@ -8,19 +8,24 @@ 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 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.65 → django_bulk_hooks-0.1.67}/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.65 → django_bulk_hooks-0.1.67}/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,
@@ -8,18 +11,17 @@ from django_bulk_hooks.constants import (
     BEFORE_DELETE,
     BEFORE_UPDATE,
 )
-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):
@@ -35,7 +37,7 @@ 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)
             engine.run(model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx)
 
             # Automatically detect fields that were modified during BEFORE_UPDATE hooks
@@ -115,7 +117,7 @@ class BulkLifecycleManager(models.Manager):
         result = []
 
         if not bypass_hooks:
-            ctx = TriggerContext(model_cls)
+            ctx = HookContext(model_cls)
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
 
         for i in range(0, len(objs), self.CHUNK_SIZE):
@@ -139,17 +141,19 @@ 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 BEFORE_DELETE hooks for %s", model_cls.__name__)
+            logger.info("Number of objects to delete: %d", len(objs))
             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
@@ -170,7 +174,7 @@ class BulkLifecycleManager(models.Manager):
         objs = list(self.all())
         if not objs:
             return 0
-        self.model.objects.bulk_delete(objs)
+        self.bulk_delete(objs)
         return len(objs)
 
     @transaction.atomic

{django_bulk_hooks-0.1.65 → django_bulk_hooks-0.1.67}/django_bulk_hooks/models.py

@@ -1,9 +1,10 @@
 from django.db import models, transaction
-from django_bulk_hooks.manager import BulkLifecycleManager
 
+from django_bulk_hooks.manager import BulkHookManager
 
-class LifecycleModelMixin(models.Model):
-    objects = BulkLifecycleManager()
+
+class HookModelMixin(models.Model):
+    objects = BulkHookManager()
 
     class Meta:
         abstract = True

{django_bulk_hooks-0.1.65 → django_bulk_hooks-0.1.67}/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.65 → django_bulk_hooks-0.1.67}/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.65 → django_bulk_hooks-0.1.67}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.65"
-description = "Lifecycle-style hooks for Django bulk operations like bulk_create and bulk_update."
+version = "0.1.67"
+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.65/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.65/django_bulk_hooks/__init__.py

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