django-bulk-hooks 0.2.68__py3-none-any.whl → 0.2.70__py3-none-any.whl

django_bulk_hooks/manager.py

@@ -21,29 +21,19 @@ class BulkHookManager(models.Manager):
     """
     Manager that provides hook-aware bulk operations.
 
-    This is a simple facade that returns HookQuerySet,
-    delegating all bulk operations to it.
+    This manager automatically applies hook functionality to its querysets.
+    It can be used as a base class or composed with other managers using
+    the queryset-based approach.
     """
 
     def get_queryset(self):
         """
         Return a HookQuerySet for this manager.
 
-        This ensures all bulk operations go through the coordinator.
+        Uses the new with_hooks() method for better composition with other managers.
         """
         base_queryset = super().get_queryset()
-
-        # If the base queryset is already a HookQuerySet, return it as-is
-        if isinstance(base_queryset, HookQuerySet):
-            return base_queryset
-
-        # Otherwise, create a new HookQuerySet with the same parameters
-        return HookQuerySet(
-            model=base_queryset.model,
-            query=base_queryset.query,
-            using=base_queryset._db,
-            hints=base_queryset._hints,
-        )
+        return HookQuerySet.with_hooks(base_queryset)
 
     def bulk_create(
         self,

django_bulk_hooks/operations/coordinator.py

@@ -938,6 +938,18 @@ class BulkOperationCoordinator:
                     except Exception as e:
                         logger.warning(f"      ❌ Failed to extract @select_related from {handler_cls.__name__}.{method_name}: {e}")
 
+        # AGGRESSIVE APPROACH: Also preload ALL relationship fields on the model
+        # This prevents N+1 queries from any relationship access during hook execution
+        try:
+            for field in self.model_cls._meta.get_fields():
+                if field.is_relation and not field.many_to_many and not field.one_to_many:
+                    # This is a forward foreign key relationship
+                    field_name = field.name
+                    logger.info(f"      🔗 AUTO: Adding all relationship fields including {field_name}")
+                    relationships.add(field_name)
+        except Exception as e:
+            logger.warning(f"      ❌ Failed to extract all relationship fields: {e}")
+
         logger.info(f"🔗 BULK PRELOAD: Total extracted relationships for {self.model_cls.__name__}: {list(relationships)}")
         return relationships
 

django_bulk_hooks/queryset.py

@@ -35,6 +35,57 @@ class HookQuerySet(models.QuerySet):
         super().__init__(*args, **kwargs)
         self._coordinator = None
 
+    @classmethod
+    def with_hooks(cls, queryset):
+        """
+        Apply hook functionality to any queryset.
+
+        This enables hooks to work with any manager by applying hook
+        capabilities at the queryset level rather than through inheritance.
+
+        Args:
+            queryset: Any Django QuerySet instance
+
+        Returns:
+            HookQuerySet instance with the same query parameters
+        """
+        if isinstance(queryset, cls):
+            return queryset  # Already has hooks
+
+        # Create a new HookQuerySet with the same parameters as the original queryset
+        hook_qs = cls(
+            model=queryset.model,
+            query=queryset.query,
+            using=queryset._db,
+            hints=getattr(queryset, '_hints', {}),
+        )
+
+        # Preserve any additional attributes from the original queryset
+        # This allows composition with other queryset enhancements
+        cls._preserve_queryset_attributes(hook_qs, queryset)
+
+        return hook_qs
+
+    @classmethod
+    def _preserve_queryset_attributes(cls, hook_qs, original_qs):
+        """
+        Preserve attributes from the original queryset.
+
+        This enables composition with other queryset enhancements like
+        queryable properties, annotations, etc.
+        """
+        # Copy non-method attributes that might be set by other managers
+        for attr_name in dir(original_qs):
+            if (not attr_name.startswith('_') and
+                not hasattr(cls, attr_name) and
+                not callable(getattr(original_qs, attr_name, None))):
+                try:
+                    value = getattr(original_qs, attr_name)
+                    setattr(hook_qs, attr_name, value)
+                except (AttributeError, TypeError):
+                    # Skip attributes that can't be copied
+                    continue
+
     @property
     def coordinator(self):
         """Lazy initialization of coordinator"""

{django_bulk_hooks-0.2.68.dist-info → django_bulk_hooks-0.2.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.68
+Version: 0.2.70
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks
@@ -244,17 +244,68 @@ LoanAccount.objects.bulk_update(reordered)  # fields are auto-detected
 
 ## 🧩 Integration with Other Managers
 
-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.
+### Recommended: QuerySet-based Composition (New Approach)
+
+For the best compatibility and to avoid inheritance conflicts, use the queryset-based composition approach:
+
+```python
+from django_bulk_hooks.queryset import HookQuerySet
+from queryable_properties.managers import QueryablePropertiesManager
+
+class MyManager(QueryablePropertiesManager):
+    """Manager that combines queryable properties with hooks"""
+
+    def get_queryset(self):
+        # Get the QueryableProperties QuerySet
+        qs = super().get_queryset()
+        # Apply hooks on top of it
+        return HookQuerySet.with_hooks(qs)
+
+class Article(models.Model):
+    title = models.CharField(max_length=100)
+    published = models.BooleanField(default=False)
+
+    objects = MyManager()
+
+# This gives you both queryable properties AND hooks
+# No inheritance conflicts, no MRO issues!
+```
+
+### Alternative: Explicit Hook Application
+
+For more control, you can apply hooks explicitly:
+
+```python
+class MyManager(QueryablePropertiesManager):
+    def get_queryset(self):
+        return super().get_queryset()
+
+    def with_hooks(self):
+        """Apply hooks to this queryset"""
+        return HookQuerySet.with_hooks(self.get_queryset())
+
+# Usage:
+Article.objects.with_hooks().filter(published=True).update(title="Updated")
+```
+
+### Legacy: Manager Inheritance (Not Recommended)
+
+The old inheritance approach still works but is not recommended due to potential MRO conflicts:
 
 ```python
 from django_bulk_hooks.manager import BulkHookManager
 from queryable_properties.managers import QueryablePropertiesManager
 
 class MyManager(BulkHookManager, QueryablePropertiesManager):
-    pass
+    pass  # ⚠️ Can cause inheritance conflicts
 ```
 
-This approach uses the industry-standard injection pattern, similar to how `QueryablePropertiesManager` works, ensuring both functionalities work seamlessly together without any framework-specific knowledge.
+**Why the new approach is better:**
+- ✅ No inheritance conflicts
+- ✅ No MRO (Method Resolution Order) issues
+- ✅ Works with any manager combination
+- ✅ Cleaner and more maintainable
+- ✅ Follows Django's queryset enhancement patterns
 
 Framework needs to:
 Register these methods

{django_bulk_hooks-0.2.68.dist-info → django_bulk_hooks-0.2.70.dist-info}/RECORD

@@ -9,19 +9,19 @@ django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,38
 django_bulk_hooks/factory.py,sha256=ezrVM5U023KZqOBbJXb6lYUP-pE7WJmi8Olh2Ew-7RA,18085
 django_bulk_hooks/handler.py,sha256=SRCrMzgolrruTkvMnYBFmXLR-ABiw0JiH3605PEdCZM,4207
 django_bulk_hooks/helpers.py,sha256=3rH9TJkdCPF7Vu--0tDaZzJg9Yxcv7yoSF1K1_-0psQ,8048
-django_bulk_hooks/manager.py,sha256=aDuP87DZLWWbDK2qeA7usl3pxoIjHFIWnQNi_jEq6z0,4446
+django_bulk_hooks/manager.py,sha256=k-uhKAzNqkxQzzH775v06g21L-LnAderBywWeJHJy38,4174
 django_bulk_hooks/models.py,sha256=TWN_F-SsLGPx9jrkNT9pmJFR5VsZ0Z_QaVOZOmt7bpw,2434
 django_bulk_hooks/operations/__init__.py,sha256=BtJYjmRhe_sScivLsniDaZmBkm0ZLvcmzXFKL7QY2Xg,550
 django_bulk_hooks/operations/analyzer.py,sha256=Pz8mc-EL8KDOfLQFYiRuN-r0OmINW3nIBhRJJCma-yo,10360
 django_bulk_hooks/operations/bulk_executor.py,sha256=po8V_2H3ULiE0RYJ-wbaRIz52SKhss81UHwuQjlz3H8,26214
-django_bulk_hooks/operations/coordinator.py,sha256=GJKP60To6A7_E3Ge_F-cGSPTx2-BHMBBtE8GK6rO-Pc,37842
+django_bulk_hooks/operations/coordinator.py,sha256=NHQWg36IvWAsbQnAppsExOhFQsvlk_VD-aMwWsoo1ao,38572
 django_bulk_hooks/operations/field_utils.py,sha256=cQ9w4xdk-z3PrMLFvRzVV07Wc0D2qbpSepwoupqwQH8,7888
 django_bulk_hooks/operations/mti_handler.py,sha256=Vmz0C0gtYDvbybmb4cDzIaGglSaQK4DQVkaBK-WuQeE,25855
 django_bulk_hooks/operations/mti_plans.py,sha256=HIRJgogHPpm6MV7nZZ-sZhMLUnozpZPV2SzwQHLRzYc,3667
 django_bulk_hooks/operations/record_classifier.py,sha256=It85hJC2K-UsEOLbTR-QBdY5UPV-acQIJ91TSGa7pYo,7053
-django_bulk_hooks/queryset.py,sha256=g_9OtOTC8FXY0hBwYr2FCqQ3mYXbfJTFPLlFV3SHmWQ,5600
+django_bulk_hooks/queryset.py,sha256=tHt1U2O9Hvozg9sdn5MjzAk_I6wDU-LupuKFTfv1SiQ,7449
 django_bulk_hooks/registry.py,sha256=4HxP1mVK2z4VzvlohbEw2359wM21UJZJYagJJ1komM0,7947
-django_bulk_hooks-0.2.68.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.2.68.dist-info/METADATA,sha256=ny5caEpFwD2Dw2sJtJHVHBL-I1pTBTdU5YDNOysuNRM,9265
-django_bulk_hooks-0.2.68.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.2.68.dist-info/RECORD,,
+django_bulk_hooks-0.2.70.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.2.70.dist-info/METADATA,sha256=cgeAfI0qSgIJJDl7WXpsqErM3YzqmuGnIeqPeSUpVOk,10555
+django_bulk_hooks-0.2.70.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.2.70.dist-info/RECORD,,