django-bulk-hooks 0.1.168__tar.gz → 0.1.169__tar.gz

{django_bulk_hooks-0.1.168 → django_bulk_hooks-0.1.169}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.168
+Version: 0.1.169
 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,7 +14,6 @@ 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-0.1.169/django_bulk_hooks/engine.py

@@ -0,0 +1,56 @@
+import logging
+
+from django.core.exceptions import ValidationError
+
+from django_bulk_hooks.registry import get_hooks
+
+logger = logging.getLogger(__name__)
+
+
+def run(model_cls, event, new_records, old_records=None, ctx=None):
+    """
+    Run hooks for a given model, event, and records.
+    """
+    if not new_records:
+        return
+
+    # Get hooks for this model and event
+    hooks = get_hooks(model_cls, event)
+
+    if not hooks:
+        return
+
+    # For BEFORE_* events, run model.clean() first for validation
+    if event.startswith("before_"):
+        for instance in new_records:
+            try:
+                instance.clean()
+            except ValidationError as e:
+                logger.error("Validation failed for %s: %s", instance, e)
+                raise
+
+    # Process hooks
+    for handler_cls, method_name, condition, priority in hooks:
+        handler_instance = handler_cls()
+        func = getattr(handler_instance, method_name)
+
+        to_process_new = []
+        to_process_old = []
+
+        for new, original in zip(
+            new_records,
+            old_records or [None] * len(new_records),
+            strict=True,
+        ):
+            if not condition or condition.check(new, original):
+                to_process_new.append(new)
+                to_process_old.append(original)
+
+        if to_process_new:
+            try:
+                func(
+                    new_records=to_process_new,
+                    old_records=to_process_old if any(to_process_old) else None,
+                )
+            except Exception as e:
+                raise

{django_bulk_hooks-0.1.168 → django_bulk_hooks-0.1.169}/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)