django-bulk-hooks 0.1.218__tar.gz → 0.1.220__tar.gz

{django_bulk_hooks-0.1.218 → django_bulk_hooks-0.1.220}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.218
+Version: 0.1.220
 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.218 → django_bulk_hooks-0.1.220}/django_bulk_hooks/conditions.py

@@ -1,3 +1,8 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
 def resolve_dotted_attr(instance, dotted_path):
     """
     Recursively resolve a dotted attribute path, e.g., "type.category".
@@ -66,11 +71,11 @@ class HasChanged(HookCondition):
         self.has_changed = has_changed
 
     def check(self, instance, original_instance=None):
-        print(f"DEBUG: HasChanged.check called for field '{self.field}' on instance {getattr(instance, 'pk', 'No PK')}")
-        print(f"DEBUG: Original instance: {getattr(original_instance, 'pk', 'No PK') if original_instance else 'None'}")
+        logger.debug(f"HasChanged.check called for field '{self.field}' on instance {getattr(instance, 'pk', 'No PK')}")
+        logger.debug(f"Original instance: {getattr(original_instance, 'pk', 'No PK') if original_instance else 'None'}")
         
         if not original_instance:
-            print(f"DEBUG: No original instance, returning False")
+            logger.debug("No original instance, returning False")
             return False
         
         current = resolve_dotted_attr(instance, self.field)
@@ -78,7 +83,7 @@ class HasChanged(HookCondition):
         
         # Add more detailed debugging
         result = (current != previous) == self.has_changed
-        print(f"DEBUG: HasChanged {self.field} result={result}")
+        logger.debug(f"HasChanged {self.field} result={result}")
         return result
 
 

{django_bulk_hooks-0.1.218 → django_bulk_hooks-0.1.220}/django_bulk_hooks/engine.py

@@ -23,11 +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 {model_cls.__name__}.{event} {len(new_records)} records")
+    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: engine.run bypassed")
+        logger.debug("engine.run bypassed")
         return
 
     # For BEFORE_* events, run model.clean() first for validation
@@ -41,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 {handler_cls.__name__}.{method_name}")
+        logger.debug(f"Processing {handler_cls.__name__}.{method_name}")
         handler_instance = handler_cls()
         func = getattr(handler_instance, method_name)
 
@@ -63,12 +63,12 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
                     to_process_old.append(original)
 
         if to_process_new:
-            print(f"DEBUG: Executing {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

{django_bulk_hooks-0.1.218 → django_bulk_hooks-0.1.220}/django_bulk_hooks/models.py

@@ -1,3 +1,4 @@
+import logging
 from django.db import models
 
 from django_bulk_hooks.constants import (
@@ -15,6 +16,8 @@ from django_bulk_hooks.context import HookContext
 from django_bulk_hooks.engine import run
 from django_bulk_hooks.manager import BulkHookManager
 
+logger = logging.getLogger(__name__)
+
 
 class HookModelMixin(models.Model):
     objects = BulkHookManager()
@@ -56,15 +59,13 @@ class HookModelMixin(models.Model):
     def save(self, *args, bypass_hooks=False, **kwargs):
         # If bypass_hooks is True, use base manager to avoid triggering hooks
         if bypass_hooks:
-            print(
-                f"DEBUG: save() called with bypass_hooks=True for {self.__class__.__name__} pk={self.pk}"
-            )
+            logger.debug(f"save() called with bypass_hooks=True for {self.__class__.__name__} pk={self.pk}")
             return self._base_manager.save(self, *args, **kwargs)
 
         is_create = self.pk is None
 
         if is_create:
-            print(f"DEBUG: save() creating new {self.__class__.__name__} instance")
+            logger.debug(f"save() creating new {self.__class__.__name__} instance")
             # For create operations, we don't have old records
             ctx = HookContext(self.__class__)
             run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
@@ -73,9 +74,7 @@ class HookModelMixin(models.Model):
 
             run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
         else:
-            print(
-                f"DEBUG: save() updating existing {self.__class__.__name__} instance pk={self.pk}"
-            )
+            logger.debug(f"save() updating existing {self.__class__.__name__} instance pk={self.pk}")
             # For update operations, we need to get the old record
             try:
                 # Use _base_manager to avoid triggering hooks recursively

{django_bulk_hooks-0.1.218 → django_bulk_hooks-0.1.220}/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,10 +81,10 @@ class HookQuerySetMixin:
         
         # If we're in a bulk operation context, skip hooks to prevent double execution
         if current_bypass_hooks:
-            print(f"DEBUG: update skipping hooks (bulk context)")
+            logger.debug("update skipping hooks (bulk context)")
             ctx = HookContext(model_cls, bypass_hooks=True)
         else:
-            print(f"DEBUG: update running hooks (standalone)")
+            logger.debug("update running hooks (standalone)")
             ctx = HookContext(model_cls, bypass_hooks=False)
             # Run validation hooks first
             engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
@@ -115,10 +118,10 @@ class HookQuerySetMixin:
 
         # Run AFTER_UPDATE hooks only for standalone updates
         if not current_bypass_hooks:
-            print(f"DEBUG: update running AFTER_UPDATE")
+            logger.debug("update running AFTER_UPDATE")
             engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
         else:
-            print(f"DEBUG: update skipping AFTER_UPDATE (bulk context)")
+            logger.debug("update skipping AFTER_UPDATE (bulk context)")
 
         return update_count
 
@@ -183,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: bulk_create bypassed hooks")
+            logger.debug("bulk_create bypassed hooks")
 
         # For MTI models, we need to handle them specially
         if is_mti:
@@ -238,7 +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 {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}")
+        logger.debug(f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}")
 
         # Check for MTI
         is_mti = False
@@ -248,11 +251,11 @@ class HookQuerySetMixin:
                 break
 
         if not bypass_hooks:
-            print(f"DEBUG: bulk_update setting bypass_hooks=False (hooks will run in update())")
+            logger.debug("bulk_update setting bypass_hooks=False (hooks will run in update())")
             ctx = HookContext(model_cls, bypass_hooks=False)
             originals = [None] * len(objs)  # Placeholder for after_update call
         else:
-            print(f"DEBUG: bulk_update setting bypass_hooks=True (no hooks)")
+            logger.debug("bulk_update setting bypass_hooks=True (no hooks)")
             ctx = HookContext(model_cls, bypass_hooks=True)
             originals = [None] * len(objs)  # Ensure originals is defined for after_update call
 
@@ -279,16 +282,16 @@ class HookQuerySetMixin:
                 for k, v in kwargs.items()
                 if k not in ["bypass_hooks", "bypass_validation"]
             }
-            print(f"DEBUG: Calling Django bulk_update")
+            logger.debug("Calling Django bulk_update")
             result = super().bulk_update(objs, fields, **django_kwargs)
-            print(f"DEBUG: Django bulk_update done: {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: bulk_update skipping AFTER_UPDATE (update() will handle)")
+            logger.debug("bulk_update skipping AFTER_UPDATE (update() will handle)")
         else:
-            print(f"DEBUG: bulk_update bypassed hooks")
+            logger.debug("bulk_update bypassed hooks")
 
         return result
 

{django_bulk_hooks-0.1.218 → django_bulk_hooks-0.1.220}/django_bulk_hooks/registry.py

@@ -1,8 +1,11 @@
+import logging
 from collections.abc import Callable
 from typing import Union
 
 from django_bulk_hooks.priority import Priority
 
+logger = logging.getLogger(__name__)
+
 _hooks: dict[tuple[type, str], list[tuple[type, str, Callable, int]]] = {}
 
 
@@ -14,13 +17,13 @@ def register_hook(
     hooks.append((handler_cls, method_name, condition, priority))
     # keep sorted by priority
     hooks.sort(key=lambda x: x[3])
-    print(f"DEBUG: Registered {handler_cls.__name__}.{method_name} for {model.__name__}.{event}")
+    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, [])
-    print(f"DEBUG: get_hooks {model.__name__}.{event} found {len(hooks)} hooks")
+    logger.debug(f"get_hooks {model.__name__}.{event} found {len(hooks)} hooks")
     return hooks
 
 

{django_bulk_hooks-0.1.218 → django_bulk_hooks-0.1.220}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.218"
+version = "0.1.220"
 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"