django-bulk-hooks 0.1.231__py3-none-any.whl → 0.1.232__py3-none-any.whl

django_bulk_hooks/registry.py

@@ -1,201 +1,34 @@
 import logging
-import threading
 from collections.abc import Callable
-from contextlib import contextmanager
-from typing import Dict, Iterable, Iterator, List, Optional, Tuple, Union
+from typing import Union
 
 from django_bulk_hooks.priority import Priority
 
 logger = logging.getLogger(__name__)
 
-# Key: (ModelClass, event)
-# Value: list of tuples (handler_cls, method_name, condition_callable, priority)
-_hooks: Dict[Tuple[type, str], List[Tuple[type, str, Callable, int]]] = {}
-_registration_counter = 0  # secondary stable ordering for tie-breaks
-
-# Registry lock for thread-safety during registration and clearing
-_lock = threading.RLock()
+_hooks: dict[tuple[type, str], list[tuple[type, str, Callable, int]]] = {}
 
 
 def register_hook(
-    model: type,
-    event: str,
-    handler_cls: type,
-    method_name: str,
-    condition: Optional[Callable],
-    priority: Union[int, Priority],
-) -> None:
-    """
-    Register a hook for a specific model and event.
-    
-    Args:
-        model: The Django model class
-        event: The hook event (e.g., 'before_create', 'after_update')
-        handler_cls: The hook handler class
-        method_name: The method name in the handler class
-        condition: Optional condition for when the hook should run
-        priority: Hook execution priority (higher numbers execute first)
-    """
-    if not model or not event or not handler_cls or not method_name:
-        logger.warning("Invalid hook registration parameters")
-        return
-
-    # Normalize event to str just in case enums are used upstream
-    event = str(event)
-
-    with _lock:
-        global _registration_counter
-        _registration_counter += 1
-        key = (model, event)
-        hooks = _hooks.setdefault(key, [])
-
-        # Check for duplicate registrations
-        duplicate = any(h[0] == handler_cls and h[1] == method_name for h in hooks)
-        if duplicate:
-            logger.warning(
-                "Hook %s.%s already registered for %s.%s",
-                handler_cls.__name__,
-                method_name,
-                model.__name__,
-                event,
-            )
-            return
-
-        # Add the hook (append preserves registration order)
-        hooks.append((handler_cls, method_name, condition, priority))
-
-        # Sort by priority (highest numbers execute first)
-        # Stable sort by priority (desc) and then by original registration order (stable append)
-        def sort_key(hook_info: Tuple[type, str, Callable, int]) -> int:
-            p = hook_info[3]
-            return p.value if hasattr(p, "value") else int(p)
-
-        hooks.sort(key=sort_key, reverse=True)
-
-        logger.debug(
-            "Registered %s.%s for %s.%s with priority %s",
-            handler_cls.__name__,
-            method_name,
-            model.__name__,
-            event,
-            priority,
-        )
-
-
-def get_hooks(model: type, event: str):
-    """
-    Get all registered hooks for a specific model and event.
-    
-    Args:
-        model: The Django model class
-        event: The hook event
-        
-    Returns:
-        List of (handler_cls, method_name, condition, priority) tuples
-    """
-    if not model or not event:
-        return []
-
-    event = str(event)
-
-    with _lock:
-        key = (model, event)
-        hooks = _hooks.get(key, [])
-
-        # Log hook discovery for debugging
-        if hooks:
-            logger.debug("Found %d hooks for %s.%s", len(hooks), model.__name__, event)
-            for handler_cls, method_name, condition, priority in hooks:
-                logger.debug("  - %s.%s (priority: %s)", handler_cls.__name__, method_name, priority)
-        else:
-            logger.debug("No hooks found for %s.%s", model.__name__, event)
-
-        # Return a shallow copy to prevent external mutation of registry state
-        return list(hooks)
-
-
-def list_all_hooks() -> Dict[Tuple[type, str], List[Tuple[type, str, Callable, int]]]:
-    """Debug function to list all registered hooks (shallow copy)."""
-    with _lock:
-        return {k: list(v) for k, v in _hooks.items()}
-
-
-def clear_hooks() -> None:
-    """Clear all registered hooks (mainly for testing)."""
-    with _lock:
-        _hooks.clear()
-        logger.debug("All hooks cleared")
-
-
-def unregister_hook(model: type, event: str, handler_cls: type, method_name: str) -> None:
-    """Unregister a previously registered hook (safe no-op if not present)."""
-    event = str(event)
-    with _lock:
-        key = (model, event)
-        if key not in _hooks:
-            return
-        _hooks[key] = [
-            h for h in _hooks[key] if not (h[0] == handler_cls and h[1] == method_name)
-        ]
-        if not _hooks[key]:
-            del _hooks[key]
-
-
-@contextmanager
-def isolated_registry() -> Iterator[None]:
-    """
-    Context manager that snapshots the hook registry and restores it on exit.
-
-    Useful for tests to avoid global cross-test interference without relying on
-    private state mutation from the outside.
-    """
-    with _lock:
-        snapshot = {k: list(v) for k, v in _hooks.items()}
-    try:
-        yield
-    finally:
-        with _lock:
-            _hooks.clear()
-            _hooks.update({k: list(v) for k, v in snapshot.items()})
-
-
-@contextmanager
-def temporary_hook(
-    model: type,
-    event: str,
-    handler_cls: type,
-    method_name: str,
-    condition: Optional[Callable] = None,
-    priority: Union[int, Priority] = Priority.NORMAL,
-) -> Iterator[None]:
-    """
-    Temporarily register a single hook for the duration of the context.
-
-    Ensures the hook is unregistered even if an exception occurs.
-    """
-    register_hook(model, event, handler_cls, method_name, condition, priority)
-    try:
-        yield
-    finally:
-        unregister_hook(model, event, handler_cls, method_name)
-
-
-@contextmanager
-def temporary_hooks(
-    registrations: Iterable[Tuple[type, str, type, str, Optional[Callable], Union[int, Priority]]]
-) -> Iterator[None]:
-    """
-    Temporarily register multiple hooks for the duration of the context.
-
-    Args:
-        registrations: Iterable of (model, event, handler_cls, method_name, condition, priority)
-    """
-    # Register all
-    for model, event, handler_cls, method_name, condition, priority in registrations:
-        register_hook(model, event, handler_cls, method_name, condition, priority)
-    try:
-        yield
-    finally:
-        # Best-effort unregister all in reverse order
-        for model, event, handler_cls, method_name, _, _ in reversed(list(registrations)):
-            unregister_hook(model, event, handler_cls, method_name)
+    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])
+    logger.debug(f"Registered {handler_cls.__name__}.{method_name} for {model.__name__}.{event}")
+
+
+def get_hooks(model, event):
+    key = (model, event)
+    hooks = _hooks.get(key, [])
+    # Only log when hooks are found or for specific events to reduce noise
+    if hooks or event in ['after_update', 'before_update', 'after_create', 'before_create']:
+        logger.debug(f"get_hooks {model.__name__}.{event} found {len(hooks)} hooks")
+    return hooks
+
+
+def list_all_hooks():
+    """Debug function to list all registered hooks"""
+    return _hooks

{django_bulk_hooks-0.1.231.dist-info → django_bulk_hooks-0.1.232.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.231
+Version: 0.1.232
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks
@@ -59,37 +59,21 @@ from django_bulk_hooks.conditions import WhenFieldHasChanged
 from .models import Account
 
 class AccountHooks(Hook):
-    @hook(AFTER_UPDATE, condition=WhenFieldHasChanged('balance'))
-    def _notify_balance_change(self, new_records, old_records, **kwargs):
-        for new_record, old_record in zip(new_records, old_records):
-            if old_record and new_record.balance != old_record.balance:
-                print(f"Balance changed from {old_record.balance} to {new_record.balance}")
-```
-
-### Bulk Operations with Hooks
-
-```python
-# For complete hook execution, use the update() method
-accounts = Account.objects.filter(active=True)
-accounts.update(balance=1000)  # Runs all hooks automatically
-
-# For bulk operations with hooks
-accounts = Account.objects.filter(active=True)
-instances = list(accounts)
-
-# bulk_update now runs complete hook cycle by default
-accounts.bulk_update(instances, ['balance'])  # Runs VALIDATE → BEFORE → DB update → AFTER
-
-# To skip hooks (for performance or when called from update())
-accounts.bulk_update(instances, ['balance'], bypass_hooks=True)
+    @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])
 ```
 
-### Understanding Hook Execution
-
-- **`update()` method**: Runs complete hook cycle (VALIDATE → BEFORE → DB update → AFTER)
-- **`bulk_update()` method**: Runs complete hook cycle (VALIDATE → BEFORE → DB update → AFTER)
-- **`bypass_hooks=True`**: Skips all hooks for performance or to prevent double execution
-
 ## 🛠 Supported Hook Events
 
 - `BEFORE_CREATE`, `AFTER_CREATE`

django_bulk_hooks-0.1.232.dist-info/RECORD

@@ -0,0 +1,17 @@
+django_bulk_hooks/__init__.py,sha256=uUgpnb9AWjIAcWNpCMqBcOewSnpJjJYH6cjPbQkzoNU,140
+django_bulk_hooks/conditions.py,sha256=V_f3Di2uCVUjoyfiU4BQCHmI4uUIRSRroApDcXlvnso,6349
+django_bulk_hooks/constants.py,sha256=3x1H1fSUUNo0DZONN7GUVDuySZctTR-jtByBHmAIX5w,303
+django_bulk_hooks/context.py,sha256=_NbGWTq9s66g0vbFIaqN4GlIHWQmFg3EQ44qY8YvvEg,1537
+django_bulk_hooks/decorators.py,sha256=WD7Jn7QAvY8F4wOsYlIpjoM9-FdHXSKB7hH9ot-lkYQ,4896
+django_bulk_hooks/engine.py,sha256=t_kvgex6_iZEFc5LK-srBTZPe-1bdlYdip5LfWOc6lc,2411
+django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
+django_bulk_hooks/handler.py,sha256=xZt8iNdYF-ACz-MnKMY0co6scWINU5V5wC1lyDn844k,4854
+django_bulk_hooks/manager.py,sha256=nfWiwU5-yAoxdnQsUMohxtyCpkV0MBv6X3wmipr9eQY,3697
+django_bulk_hooks/models.py,sha256=exnXYVKEVbYAXhChCP8VdWTnKCnm9DiTcokEIBee1I0,4350
+django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
+django_bulk_hooks/queryset.py,sha256=YSDCMAf24YLeLJrRKCDYwbZInP2mK_Tcuw3EHLDkv_w,32605
+django_bulk_hooks/registry.py,sha256=8UuhniiH5ChSeOKV1UUbqTEiIu25bZXvcHmkaRbxmME,1131
+django_bulk_hooks-0.1.232.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.232.dist-info/METADATA,sha256=f8DOScqSoznpOeAOoIYha3lTiWcDp0aEk8lRihqKjiM,9061
+django_bulk_hooks-0.1.232.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.1.232.dist-info/RECORD,,

django_bulk_hooks-0.1.231.dist-info/RECORD

@@ -1,17 +0,0 @@
-django_bulk_hooks/__init__.py,sha256=-HwaG02h62oqcjMxlVil6hNJviUaOwjVOerRLPlcNn4,427
-django_bulk_hooks/conditions.py,sha256=7C0enCYMgmIP0WO9Sf_rBbmdHC1yORMELAFoyuBcGgs,7169
-django_bulk_hooks/constants.py,sha256=3x1H1fSUUNo0DZONN7GUVDuySZctTR-jtByBHmAIX5w,303
-django_bulk_hooks/context.py,sha256=L95s1n9N5oBdfdrIA3_zoi0tf7GnDVrQxYaSXPwBkvg,2626
-django_bulk_hooks/decorators.py,sha256=Uxey4ED4x2ky0CVP3yGhn5BUltT1SdDAchU0BcMUgMg,8919
-django_bulk_hooks/engine.py,sha256=5CNvvnfeKxlh0sv55a9_fAFozlID7LEFxel6w0DtwPs,6152
-django_bulk_hooks/enums.py,sha256=ZSYPwHcjlAMrISOHb9sqNjEfxyv4XupoDoe1hn87VJg,499
-django_bulk_hooks/handler.py,sha256=zR1H1qwID4y1sxOZvBD2Vo7RvuclzzuWwA-_tjEMeu0,3955
-django_bulk_hooks/manager.py,sha256=uqmvGlskkzKMERf3iexxXCAaQl0v3Wc45BeN-YmfTnE,4060
-django_bulk_hooks/models.py,sha256=saCZGk-i-ixUq7ds59tl-SdzQ18slFbQKHnOtruxzmc,6428
-django_bulk_hooks/priority.py,sha256=EGFBbRmX_LhwRYFCKzM8I5m8NGCsUEVJp2pfNTcoHe4,378
-django_bulk_hooks/queryset.py,sha256=u8Abj_W5cABM9pi-vQG_6zGsekbPI6It3tA_zDHUDC4,37480
-django_bulk_hooks/registry.py,sha256=VyniRXVgeWq-3RmveXzoG3FjvOhXwwm89Z5CzAgkkU4,6648
-django_bulk_hooks-0.1.231.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.231.dist-info/METADATA,sha256=whqmfiC35Q3I9-epd68ca85QQsJlNyVWqpi-_5DY1TM,9743
-django_bulk_hooks-0.1.231.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.1.231.dist-info/RECORD,,