django-bulk-hooks 0.1.188__tar.gz → 0.1.190__tar.gz

{django_bulk_hooks-0.1.188 → django_bulk_hooks-0.1.190}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.188
+Version: 0.1.190
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks
@@ -202,15 +202,20 @@ reordered = [account3, account1, account2]  # IDs: 3, 1, 2
 LoanAccount.objects.bulk_update(reordered, ['balance'])
 ```
 
-## 🧩 Integration with Queryable Properties
+## 🧩 Integration with Other Managers
 
-You can extend from `BulkHookManager` to support formula fields or property querying.
+You can extend from `BulkHookManager` to work with other manager classes. The manager uses a cooperative approach that dynamically injects bulk hook functionality into any queryset, ensuring compatibility with other managers.
 
 ```python
+from django_bulk_hooks.manager import BulkHookManager
+from queryable_properties.managers import QueryablePropertiesManager
+
 class MyManager(BulkHookManager, QueryablePropertiesManager):
     pass
 ```
 
+This approach uses the industry-standard injection pattern, similar to how `QueryablePropertiesManager` works, ensuring both functionalities work seamlessly together without any framework-specific knowledge.
+
 ## 📝 License
 
 MIT © 2024 Augend / Konrad Beck

{django_bulk_hooks-0.1.188 → django_bulk_hooks-0.1.190}/README.md

@@ -183,15 +183,20 @@ reordered = [account3, account1, account2]  # IDs: 3, 1, 2
 LoanAccount.objects.bulk_update(reordered, ['balance'])
 ```
 
-## 🧩 Integration with Queryable Properties
+## 🧩 Integration with Other Managers
 
-You can extend from `BulkHookManager` to support formula fields or property querying.
+You can extend from `BulkHookManager` to work with other manager classes. The manager uses a cooperative approach that dynamically injects bulk hook functionality into any queryset, ensuring compatibility with other managers.
 
 ```python
+from django_bulk_hooks.manager import BulkHookManager
+from queryable_properties.managers import QueryablePropertiesManager
+
 class MyManager(BulkHookManager, QueryablePropertiesManager):
     pass
 ```
 
+This approach uses the industry-standard injection pattern, similar to how `QueryablePropertiesManager` works, ensuring both functionalities work seamlessly together without any framework-specific knowledge.
+
 ## 📝 License
 
 MIT © 2024 Augend / Konrad Beck

{django_bulk_hooks-0.1.188 → django_bulk_hooks-0.1.190}/django_bulk_hooks/manager.py

@@ -1,12 +1,57 @@
 from django.db import models
 
-from django_bulk_hooks.queryset import HookQuerySet
+from django_bulk_hooks.queryset import HookQuerySet, HookQuerySetMixin
+
+
+def inject_bulk_hook_behavior(queryset):
+    """
+    Dynamically inject bulk hook behavior into any queryset.
+    This follows the industry-standard pattern for cooperative queryset extensions.
+    
+    Args:
+        queryset: Any Django QuerySet instance
+        
+    Returns:
+        A new queryset instance with bulk hook functionality added
+    """
+    if isinstance(queryset, HookQuerySetMixin):
+        # Already has hook functionality, return as-is
+        return queryset
+    
+    # Create a new class that inherits from both HookQuerySetMixin and the queryset's class
+    HookedQuerySetClass = type(
+        "HookedQuerySet",
+        (HookQuerySetMixin, queryset.__class__),
+        {
+            '__module__': 'django_bulk_hooks.queryset',
+            '__doc__': f'Dynamically created queryset with bulk hook functionality for {queryset.__class__.__name__}'
+        }
+    )
+    
+    # Create a new instance with the same parameters
+    new_queryset = HookedQuerySetClass(
+        model=queryset.model,
+        query=queryset.query,
+        using=queryset._db,
+        hints=queryset._hints
+    )
+    
+    # Copy any additional attributes that might be important
+    for attr, value in queryset.__dict__.items():
+        if not hasattr(new_queryset, attr):
+            setattr(new_queryset, attr, value)
+    
+    return new_queryset
 
 
 class BulkHookManager(models.Manager):
     def get_queryset(self):
-        queryset = HookQuerySet(self.model, using=self._db)
-        return queryset
+        # Use super().get_queryset() to let Django and MRO build the queryset
+        # This ensures cooperation with other managers
+        base_queryset = super().get_queryset()
+        
+        # Inject our bulk hook behavior into the queryset
+        return inject_bulk_hook_behavior(base_queryset)
 
     def bulk_create(
         self,

{django_bulk_hooks-0.1.188 → django_bulk_hooks-0.1.190}/django_bulk_hooks/queryset.py

@@ -17,7 +17,12 @@ from django_bulk_hooks.context import HookContext
 from django.db.models import When, Value, Case
 
 
-class HookQuerySet(models.QuerySet):
+class HookQuerySetMixin:
+    """
+    A mixin that provides bulk hook functionality to any QuerySet.
+    This can be dynamically injected into querysets from other managers.
+    """
+    
     @transaction.atomic
     def delete(self):
         objs = list(self)
@@ -637,10 +642,16 @@ class HookQuerySet(models.QuerySet):
         # If objects have pk set but are not loaded from DB, use those PKs
         root_pks = []
         for obj in batch:
-            if obj.pk is not None:
-                root_pks.append(obj.pk)
+            # Check both pk and id attributes
+            pk_value = getattr(obj, 'pk', None)
+            if pk_value is None:
+                pk_value = getattr(obj, 'id', None)
+            
+            if pk_value is not None:
+                root_pks.append(pk_value)
+                print(f"Found PK {pk_value} for object {obj}")
             else:
-                print(f"WARNING: Object {obj} has no primary key")
+                print(f"WARNING: Object {obj} has no primary key (pk={getattr(obj, 'pk', None)}, id={getattr(obj, 'id', None)})")
                 continue
         
         print(f"Root PKs to update: {root_pks}")
@@ -703,7 +714,12 @@ class HookQuerySet(models.QuerySet):
                     
                     print(f"Building CASE statement for field: {field_name}")
                     for pk, obj in zip(pks, batch):
-                        if obj.pk is None:
+                        # Check both pk and id attributes for the object
+                        obj_pk = getattr(obj, 'pk', None)
+                        if obj_pk is None:
+                            obj_pk = getattr(obj, 'id', None)
+                        
+                        if obj_pk is None:
                             continue
                         value = getattr(obj, field_name)
                         print(f"  PK {pk}: {field_name} = {value}")
@@ -727,3 +743,11 @@ class HookQuerySet(models.QuerySet):
 
         print(f"Batch total updated: {total_updated}")
         return total_updated
+
+
+class HookQuerySet(HookQuerySetMixin, models.QuerySet):
+    """
+    A QuerySet that provides bulk hook functionality.
+    This is the traditional approach for backward compatibility.
+    """
+    pass

{django_bulk_hooks-0.1.188 → django_bulk_hooks-0.1.190}/pyproject.toml

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