django-bulk-hooks 0.1.217__tar.gz → 0.1.219__tar.gz

{django_bulk_hooks-0.1.217 → django_bulk_hooks-0.1.219}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.217
+Version: 0.1.219
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.1.217 → django_bulk_hooks-0.1.219}/django_bulk_hooks/conditions.py

@@ -77,13 +77,8 @@ class HasChanged(HookCondition):
         previous = resolve_dotted_attr(original_instance, self.field)
         
         # Add more detailed debugging
-        print(f"DEBUG: Field '{self.field}' - current value: {current} (type: {type(current)})")
-        print(f"DEBUG: Field '{self.field}' - previous value: {previous} (type: {type(previous)})")
-        print(f"DEBUG: Values are equal: {current == previous}")
-        
         result = (current != previous) == self.has_changed
-        print(f"DEBUG: HasChanged result: current={current}, previous={previous}, has_changed={self.has_changed}, result={result}")
-        
+        print(f"DEBUG: HasChanged {self.field} result={result}")
         return result
 
 

{django_bulk_hooks-0.1.217 → django_bulk_hooks-0.1.219}/django_bulk_hooks/engine.py

@@ -23,17 +23,11 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
     import traceback
 
     stack = traceback.format_stack()
-    print(
-        f"DEBUG: engine.run called for {model_cls.__name__}.{event} with {len(new_records)} records"
-    )
-    print(f"DEBUG: Call stack (last 3 frames):")
-    for line in stack[-4:-1]:  # Show last 3 frames before this one
-        print(f"  {line.strip()}")
-    print(f"DEBUG: Total hooks found: {len(hooks)}")
+    logger.debug(f"engine.run {model_cls.__name__}.{event} {len(new_records)} records")
     
     # Check if we're in a bypass context
     if ctx and hasattr(ctx, 'bypass_hooks') and ctx.bypass_hooks:
-        print(f"DEBUG: Context has bypass_hooks=True, skipping hook execution")
+        logger.debug("engine.run bypassed")
         return
 
     # For BEFORE_* events, run model.clean() first for validation
@@ -47,7 +41,7 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
 
     # Process hooks
     for handler_cls, method_name, condition, priority in hooks:
-        print(f"DEBUG: Processing hook {handler_cls.__name__}.{method_name} with condition: {condition}")
+        logger.debug(f"Processing {handler_cls.__name__}.{method_name}")
         handler_instance = handler_cls()
         func = getattr(handler_instance, method_name)
 
@@ -60,27 +54,21 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
             strict=True,
         ):
             if not condition:
-                print(f"DEBUG: No condition, adding record {new.pk if hasattr(new, 'pk') else 'No PK'}")
                 to_process_new.append(new)
                 to_process_old.append(original)
             else:
                 condition_result = condition.check(new, original)
-                print(f"DEBUG: Condition {condition.__class__.__name__} check result: {condition_result} for record {new.pk if hasattr(new, 'pk') else 'No PK'}")
                 if condition_result:
                     to_process_new.append(new)
                     to_process_old.append(original)
 
         if to_process_new:
-            print(
-                f"DEBUG: Executing hook {handler_cls.__name__}.{method_name} for {len(to_process_new)} records"
-            )
+            logger.debug(f"Executing {handler_cls.__name__}.{method_name} for {len(to_process_new)} records")
             try:
                 func(
                     new_records=to_process_new,
                     old_records=to_process_old if any(to_process_old) else None,
                 )
             except Exception as e:
-                print(f"DEBUG: Hook execution failed: {e}")
+                logger.debug(f"Hook execution failed: {e}")
                 raise
-        else:
-            print(f"DEBUG: No records to process for hook {handler_cls.__name__}.{method_name}")

{django_bulk_hooks-0.1.217 → django_bulk_hooks-0.1.219}/django_bulk_hooks/queryset.py

@@ -1,7 +1,10 @@
+import logging
 from django.db import models, transaction
 from django.db.models import AutoField, Case, Field, Value, When
 
 from django_bulk_hooks import engine
+
+logger = logging.getLogger(__name__)
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -78,12 +81,14 @@ class HookQuerySetMixin:
         
         # If we're in a bulk operation context, skip hooks to prevent double execution
         if current_bypass_hooks:
-            print(f"DEBUG: update method skipping hooks due to bulk operation context")
+            logger.debug("update skipping hooks (bulk context)")
             ctx = HookContext(model_cls, bypass_hooks=True)
         else:
-            print(f"DEBUG: update method running hooks (standalone update)")
+            logger.debug("update running hooks (standalone)")
             ctx = HookContext(model_cls, bypass_hooks=False)
-            # Run BEFORE_UPDATE hooks only for standalone updates
+            # Run validation hooks first
+            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
+            # Then run BEFORE_UPDATE hooks
             engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
         # Use Django's built-in update logic directly
@@ -113,10 +118,10 @@ class HookQuerySetMixin:
 
         # Run AFTER_UPDATE hooks only for standalone updates
         if not current_bypass_hooks:
-            print(f"DEBUG: update method running AFTER_UPDATE hooks")
+            logger.debug("update running AFTER_UPDATE")
             engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
         else:
-            print(f"DEBUG: update method skipping AFTER_UPDATE hooks due to bulk operation context")
+            logger.debug("update skipping AFTER_UPDATE (bulk context)")
 
         return update_count
 
@@ -181,7 +186,7 @@ class HookQuerySetMixin:
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
         else:
             ctx = HookContext(model_cls, bypass_hooks=True) # Pass bypass_hooks
-            print(f"DEBUG: Set thread-local bypass_hooks=True for nested calls in bulk_create")
+            logger.debug("bulk_create bypassed hooks")
 
         # For MTI models, we need to handle them specially
         if is_mti:
@@ -236,9 +241,7 @@ class HookQuerySetMixin:
                 f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        print(f"DEBUG: bulk_update called with bypass_hooks={bypass_hooks} (type: {type(bypass_hooks)}), bypass_validation={bypass_validation}")
-        print(f"DEBUG: bulk_update for model {model_cls.__name__} with {len(objs)} objects")
-        print(f"DEBUG: kwargs: {kwargs}")
+        logger.debug(f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}")
 
         # Check for MTI
         is_mti = False
@@ -248,31 +251,12 @@ class HookQuerySetMixin:
                 break
 
         if not bypass_hooks:
-            print(f"DEBUG: bulk_update running hooks for {len(objs)} objects")
-            original_map = {
-                obj.pk: obj
-                for obj in model_cls._base_manager.filter(
-                    pk__in=[obj.pk for obj in objs]
-                )
-            }
-            originals = [original_map.get(obj.pk) for obj in objs]
+            logger.debug("bulk_update setting bypass_hooks=False (hooks will run in update())")
             ctx = HookContext(model_cls, bypass_hooks=False)
-            # Run validation hooks first
-            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)
-
-            # Detect modified fields during hooks
-            modified_fields = self._detect_modified_fields(objs, originals)
-            if modified_fields:
-                fields_set = set(fields)
-                fields_set.update(modified_fields)
-                fields = list(fields_set)
+            originals = [None] * len(objs)  # Placeholder for after_update call
         else:
-            print(f"DEBUG: bulk_update skipping hooks and setting bulk context to prevent double execution")
+            logger.debug("bulk_update setting bypass_hooks=True (no hooks)")
             ctx = HookContext(model_cls, bypass_hooks=True)
-            print(f"DEBUG: Set thread-local bypass_hooks=True to prevent nested update() calls from running hooks")
             originals = [None] * len(objs)  # Ensure originals is defined for after_update call
 
         # Handle auto_now fields like Django's update_or_create does
@@ -298,22 +282,16 @@ class HookQuerySetMixin:
                 for k, v in kwargs.items()
                 if k not in ["bypass_hooks", "bypass_validation"]
             }
-            print(f"DEBUG: Calling Django's bulk_update with kwargs: {django_kwargs}")
-            # Call Django's bulk_update with hook suspension to prevent double execution
-            # Django's bulk_update internally calls .update() which would trigger our hooks again
-            print(f"DEBUG: About to call Django's bulk_update")
+            logger.debug("Calling Django bulk_update")
             result = super().bulk_update(objs, fields, **django_kwargs)
-            print(f"DEBUG: Django's bulk_update completed, result: {result}")
+            logger.debug(f"Django bulk_update done: {result}")
 
+        # Note: We don't run AFTER_UPDATE hooks here to prevent double execution
+        # The update() method will handle all hook execution based on thread-local state
         if not bypass_hooks:
-            print(
-                f"DEBUG: bypass_hooks=False, running AFTER_UPDATE hooks for {len(objs)} objects"
-            )
-            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
+            logger.debug("bulk_update skipping AFTER_UPDATE (update() will handle)")
         else:
-            print(
-                f"DEBUG: bypass_hooks=True, skipping AFTER_UPDATE hooks for {len(objs)} objects"
-            )
+            logger.debug("bulk_update bypassed hooks")
 
         return result
 

django_bulk_hooks-0.1.219/django_bulk_hooks/registry.py

@@ -0,0 +1,29 @@
+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])
+    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, [])
+    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.217 → django_bulk_hooks-0.1.219}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.217"
+version = "0.1.219"
 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.217/django_bulk_hooks/registry.py

@@ -1,37 +0,0 @@
-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])
-    print(f"DEBUG: Registered hook {handler_cls.__name__}.{method_name} for {model.__name__}.{event} with condition: {condition}")
-    print(f"DEBUG: Model class: {model} (id: {id(model)})")
-    print(f"DEBUG: Total hooks for {model.__name__}.{event}: {len(hooks)}")
-
-
-def get_hooks(model, event):
-    key = (model, event)
-    hooks = _hooks.get(key, [])
-    print(f"DEBUG: get_hooks called for {model.__name__}.{event}, found {len(hooks)} hooks")
-    print(f"DEBUG: Hook key: {key}")
-    print(f"DEBUG: Model class: {model} (id: {id(model)})")
-    print(f"DEBUG: All registered hook keys: {list(_hooks.keys())}")
-    for hook in hooks:
-        handler_cls, method_name, condition, priority = hook
-        print(f"DEBUG: Hook: {handler_cls.__name__}.{method_name} with condition: {condition}")
-    return hooks
-
-
-def list_all_hooks():
-    """Debug function to list all registered hooks"""
-    return _hooks