django-bulk-hooks 0.1.167__py3-none-any.whl → 0.1.169__py3-none-any.whl

django_bulk_hooks/decorators.py

@@ -66,7 +66,8 @@ def select_related(*related_fields):
 
             fetched = {}
             if ids_to_fetch:
-                fetched = model_cls.objects.select_related(*related_fields).in_bulk(ids_to_fetch)
+                # Use the base manager to avoid recursion
+                fetched = model_cls._base_manager.select_related(*related_fields).in_bulk(ids_to_fetch)
 
             for obj in new_records:
                 preloaded = fetched.get(obj.pk)

django_bulk_hooks/engine.py

@@ -11,20 +11,13 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
     """
     Run hooks for a given model, event, and records.
     """
-    print(f"DEBUG: engine.run called for {model_cls} with event {event}")
-    print(f"DEBUG: Number of new_records: {len(new_records) if new_records else 0}")
-    print(f"DEBUG: Number of old_records: {len(old_records) if old_records else 0}")
-    
     if not new_records:
-        print(f"DEBUG: No new_records, skipping hooks")
         return
 
     # Get hooks for this model and event
     hooks = get_hooks(model_cls, event)
-    print(f"DEBUG: Found {len(hooks)} hooks for {model_cls}.{event}")
-    
+
     if not hooks:
-        print(f"DEBUG: No hooks found for {model_cls}.{event}")
         return
 
     # For BEFORE_* events, run model.clean() first for validation
@@ -38,7 +31,6 @@ 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}")
         handler_instance = handler_cls()
         func = getattr(handler_instance, method_name)
 
@@ -50,24 +42,15 @@ def run(model_cls, event, new_records, old_records=None, ctx=None):
             old_records or [None] * len(new_records),
             strict=True,
         ):
-            print(f"DEBUG: Checking condition for {handler_cls.__name__}.{method_name}")
-            print(f"DEBUG:  - new: {type(new)}")
-            print(f"DEBUG:  - original: {type(original)}")
-            print(f"DEBUG:  - condition: {condition}")
             if not condition or condition.check(new, original):
-                print(f"DEBUG:  - condition passed, adding to process list")
                 to_process_new.append(new)
                 to_process_old.append(original)
-            else:
-                print(f"DEBUG:  - condition failed, skipping")
 
         if to_process_new:
-            print(f"DEBUG: Executing hook {handler_cls.__name__}.{method_name} with {len(to_process_new)} records")
             try:
-                func(new_records=to_process_new, old_records=to_process_old if any(to_process_old) else None)
-                print(f"DEBUG: Hook {handler_cls.__name__}.{method_name} executed successfully")
+                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 {handler_cls.__name__}.{method_name} failed with error: {e}")
                 raise
-        else:
-            print(f"DEBUG: Skipping hook {handler_cls.__name__}.{method_name} - no records to process")

django_bulk_hooks/manager.py

@@ -6,8 +6,6 @@ from django_bulk_hooks.queryset import HookQuerySet
 class BulkHookManager(models.Manager):
     def get_queryset(self):
         qs = HookQuerySet(self.model, using=self._db)
-        print(f"DEBUG: BulkHookManager.get_queryset() called for {self.model}")
-        print(f"DEBUG: Returning QuerySet type: {type(qs)}")
         return qs
 
     def bulk_update(
@@ -18,23 +16,29 @@ class BulkHookManager(models.Manager):
         This follows Django's pattern where Manager methods call QuerySet methods.
         """
         import inspect
+
         qs = self.get_queryset()
-        method = qs.bulk_update
-        print(f"DEBUG: bulk_update method signature: {inspect.signature(method)}")
-        print(f"DEBUG: Calling with args: objs={type(objs)}, fields={fields}, bypass_hooks={bypass_hooks}, bypass_validation={bypass_validation}, kwargs={kwargs}")
-        print(f"DEBUG: QuerySet class: {type(qs)}")
-        print(f"DEBUG: Manager type: {type(self)}")
-        print(f"DEBUG: Model: {self.model}")
-        
+
         # Check if this is our HookQuerySet or a different QuerySet
-        if hasattr(qs, 'bulk_update') and 'bypass_hooks' in inspect.signature(qs.bulk_update).parameters:
+        if (
+            hasattr(qs, "bulk_update")
+            and "bypass_hooks" in inspect.signature(qs.bulk_update).parameters
+        ):
             # Our HookQuerySet - pass all parameters
-            print(f"DEBUG: Using our HookQuerySet for {self.model}")
-            return qs.bulk_update(objs, fields, bypass_hooks=bypass_hooks, bypass_validation=bypass_validation, **kwargs)
+            return qs.bulk_update(
+                objs,
+                fields,
+                bypass_hooks=bypass_hooks,
+                bypass_validation=bypass_validation,
+                **kwargs,
+            )
         else:
             # Different QuerySet (like queryable_properties) - only pass standard parameters
-            print(f"DEBUG: Using different QuerySet ({type(qs)}) for {self.model}, bypassing hooks")
-            django_kwargs = {k: v for k, v in kwargs.items() if k not in ['bypass_hooks', 'bypass_validation']}
+            django_kwargs = {
+                k: v
+                for k, v in kwargs.items()
+                if k not in ["bypass_hooks", "bypass_validation"]
+            }
             return qs.bulk_update(objs, fields, **django_kwargs)
 
     def bulk_create(
@@ -53,30 +57,36 @@ class BulkHookManager(models.Manager):
         This follows Django's pattern where Manager methods call QuerySet methods.
         """
         import inspect
+
         qs = self.get_queryset()
-        method = qs.bulk_create
-        
+
         # Check if this is our HookQuerySet or a different QuerySet
-        if hasattr(qs, 'bulk_create') and 'bypass_hooks' in inspect.signature(qs.bulk_create).parameters:
+        if (
+            hasattr(qs, "bulk_create")
+            and "bypass_hooks" in inspect.signature(qs.bulk_create).parameters
+        ):
             # Our HookQuerySet - pass all parameters
-            print(f"DEBUG: Using our HookQuerySet for {self.model}")
             kwargs = {
-                'batch_size': batch_size,
-                'ignore_conflicts': ignore_conflicts,
-                'update_conflicts': update_conflicts,
-                'update_fields': update_fields,
-                'unique_fields': unique_fields,
+                "batch_size": batch_size,
+                "ignore_conflicts": ignore_conflicts,
+                "update_conflicts": update_conflicts,
+                "update_fields": update_fields,
+                "unique_fields": unique_fields,
             }
-            return qs.bulk_create(objs, bypass_hooks=bypass_hooks, bypass_validation=bypass_validation, **kwargs)
+            return qs.bulk_create(
+                objs,
+                bypass_hooks=bypass_hooks,
+                bypass_validation=bypass_validation,
+                **kwargs,
+            )
         else:
             # Different QuerySet - only pass standard parameters
-            print(f"DEBUG: Using different QuerySet ({type(qs)}) for {self.model}, bypassing hooks")
             kwargs = {
-                'batch_size': batch_size,
-                'ignore_conflicts': ignore_conflicts,
-                'update_conflicts': update_conflicts,
-                'update_fields': update_fields,
-                'unique_fields': unique_fields,
+                "batch_size": batch_size,
+                "ignore_conflicts": ignore_conflicts,
+                "update_conflicts": update_conflicts,
+                "update_fields": update_fields,
+                "unique_fields": unique_fields,
             }
             return qs.bulk_create(objs, **kwargs)
 
@@ -88,22 +98,28 @@ class BulkHookManager(models.Manager):
         This follows Django's pattern where Manager methods call QuerySet methods.
         """
         import inspect
+
         qs = self.get_queryset()
-        method = qs.bulk_delete
-        
+
         # Check if this is our HookQuerySet or a different QuerySet
-        if hasattr(qs, 'bulk_delete') and 'bypass_hooks' in inspect.signature(qs.bulk_delete).parameters:
+        if (
+            hasattr(qs, "bulk_delete")
+            and "bypass_hooks" in inspect.signature(qs.bulk_delete).parameters
+        ):
             # Our HookQuerySet - pass all parameters
-            print(f"DEBUG: Using our HookQuerySet for {self.model}")
             kwargs = {
-                'batch_size': batch_size,
+                "batch_size": batch_size,
             }
-            return qs.bulk_delete(objs, bypass_hooks=bypass_hooks, bypass_validation=bypass_validation, **kwargs)
+            return qs.bulk_delete(
+                objs,
+                bypass_hooks=bypass_hooks,
+                bypass_validation=bypass_validation,
+                **kwargs,
+            )
         else:
             # Different QuerySet - only pass standard parameters
-            print(f"DEBUG: Using different QuerySet ({type(qs)}) for {self.model}, bypassing hooks")
             kwargs = {
-                'batch_size': batch_size,
+                "batch_size": batch_size,
             }
             return qs.bulk_delete(objs, **kwargs)