django-bulk-hooks 0.1.233__tar.gz → 0.1.234__tar.gz

{django_bulk_hooks-0.1.233 → django_bulk_hooks-0.1.234}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.233
+Version: 0.1.234
 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

{django_bulk_hooks-0.1.233 → django_bulk_hooks-0.1.234}/django_bulk_hooks/queryset.py

@@ -1,11 +1,11 @@
 import logging
+from typing import Any
 
 from django.db import models, transaction
 from django.db.models import AutoField, Case, Value, When
+from django.db.models.functions import Cast
 
 from django_bulk_hooks import engine
-
-logger = logging.getLogger(__name__)
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -19,6 +19,8 @@ from django_bulk_hooks.constants import (
 )
 from django_bulk_hooks.context import HookContext
 
+logger = logging.getLogger(__name__)
+
 
 class HookQuerySetMixin:
     """
@@ -27,7 +29,7 @@ class HookQuerySetMixin:
     """
 
     @transaction.atomic
-    def delete(self):
+    def delete(self) -> int:
         objs = list(self)
         if not objs:
             return 0
@@ -35,22 +37,18 @@ class HookQuerySetMixin:
         model_cls = self.model
         ctx = HookContext(model_cls)
 
-        # Run validation hooks first
         engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
 
-        # Then run business logic hooks
         engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
 
-        # Use Django's standard delete() method
         result = super().delete()
 
-        # Run AFTER_DELETE hooks
         engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
 
         return result
 
     @transaction.atomic
-    def update(self, **kwargs):
+    def update(self, **kwargs) -> int:
         instances = list(self)
         if not instances:
             return 0
@@ -95,8 +93,6 @@ class HookQuerySetMixin:
         # Use original kwargs so Django can handle subqueries at database level
         update_count = super().update(**kwargs)
 
-        # Since we resolved subqueries upfront, we don't need the post-refresh logic
-
         # Run AFTER_UPDATE hooks only for standalone updates
         if not current_bypass_hooks:
             logger.debug("update: running AFTER_UPDATE")
@@ -106,34 +102,57 @@ class HookQuerySetMixin:
 
         return update_count
 
-    def _resolve_subquery_values(self, kwargs):
+    def _resolve_subquery_values(self, kwargs) -> dict[str, Any]:
         """
         Resolve Subquery objects to their actual values by evaluating them
         against the database. This ensures hooks receive resolved values
         instead of raw Subquery objects.
         """
         resolved_kwargs = {}
+
+        # Check if we have any data to evaluate against
+        has_data = self.model._default_manager.exists()
+
         for field, value in kwargs.items():
-            if hasattr(value, "query") and hasattr(value, "resolve_expression"):
-                # This is a subquery - we need to resolve it
+            # Handle Cast expressions
+            if isinstance(value, Cast):
+                if has_data:
+                    # Try to resolve Cast expression
+                    try:
+                        temp_qs = self.model._default_manager.all()
+                        temp_qs = temp_qs.annotate(_temp_field=value)
+                        temp_qs = temp_qs.values("_temp_field")
+                        result = temp_qs.first()
+                        if result is not None:
+                            resolved_kwargs[field] = result["_temp_field"]
+                        else:
+                            resolved_kwargs[field] = value
+                    except Exception:
+                        logger.warning(
+                            f"Failed to resolve Cast expression for field {field}"
+                        )
+                        resolved_kwargs[field] = value
+                else:
+                    # No data to evaluate against, use original
+                    resolved_kwargs[field] = value
+
+            # Handle Subquery expressions
+            elif hasattr(value, "query") and hasattr(value, "resolve_expression"):
                 try:
-                    # Create a temporary queryset to evaluate the subquery
                     temp_qs = self.model._default_manager.all()
                     temp_qs = temp_qs.annotate(_temp_field=value)
                     temp_qs = temp_qs.values("_temp_field")
-
-                    # Get the resolved value (assuming single result for update context)
-                    resolved_value = temp_qs.first()["_temp_field"]
-                    resolved_kwargs[field] = resolved_value
+                    result = temp_qs.first()
+                    if result is not None:
+                        resolved_kwargs[field] = result["_temp_field"]
+                    else:
+                        resolved_kwargs[field] = value
                 except Exception:
-                    # If resolution fails, use the original subquery
-                    # Django's update() will handle it at the database level
-                    logger.warning(
-                        f"Failed to resolve subquery for field {field}, using original"
-                    )
+                    logger.warning(f"Failed to resolve subquery for field {field}")
                     resolved_kwargs[field] = value
+
+            # Handle regular values
             else:
-                # Not a subquery, use as-is
                 resolved_kwargs[field] = value
 
         return resolved_kwargs
@@ -149,7 +168,7 @@ class HookQuerySetMixin:
         unique_fields=None,
         bypass_hooks=False,
         bypass_validation=False,
-    ):
+    ) -> list[Any]:
         """
         Insert each of the instances into the database. Behaves like Django's bulk_create,
         but supports multi-table inheritance (MTI) models and hooks. All arguments are supported and
@@ -240,7 +259,7 @@ class HookQuerySetMixin:
     @transaction.atomic
     def bulk_update(
         self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
-    ):
+    ) -> int:
         """
         Bulk update objects in the database with MTI support.
         """
@@ -312,7 +331,7 @@ class HookQuerySetMixin:
 
         return result
 
-    def _detect_modified_fields(self, new_instances, original_instances):
+    def _detect_modified_fields(self, new_instances, original_instances) -> set[str]:
         """
         Detect fields that were modified during BEFORE_UPDATE hooks by comparing
         new instances with their original values.
@@ -349,7 +368,7 @@ class HookQuerySetMixin:
 
         return modified_fields
 
-    def _get_inheritance_chain(self):
+    def _get_inheritance_chain(self) -> list[type[models.Model]]:
         """
         Get the complete inheritance chain from root parent to current model.
         Returns list of model classes in order: [RootParent, Parent, Child]
@@ -370,7 +389,7 @@ class HookQuerySetMixin:
         chain.reverse()
         return chain
 
-    def _mti_bulk_create(self, objs, inheritance_chain=None, **kwargs):
+    def _mti_bulk_create(self, objs, inheritance_chain=None, **kwargs) -> list[Any]:
         """
         Implements Django's suggested workaround #2 for MTI bulk_create:
         O(n) normal inserts into parent tables to get primary keys back,
@@ -403,7 +422,9 @@ class HookQuerySetMixin:
                 created_objects.extend(batch_result)
         return created_objects
 
-    def _process_mti_bulk_create_batch(self, batch, inheritance_chain, **kwargs):
+    def _process_mti_bulk_create_batch(
+        self, batch, inheritance_chain, **kwargs
+    ) -> list[Any]:
         """
         Process a single batch of objects through the inheritance chain.
         Implements Django's suggested workaround #2: O(n) normal inserts into parent
@@ -605,7 +626,7 @@ class HookQuerySetMixin:
 
         return child_obj
 
-    def _mti_bulk_update(self, objs, fields, **kwargs):
+    def _mti_bulk_update(self, objs, fields, **kwargs) -> int:
         """
         Custom bulk update implementation for MTI models.
         Updates each table in the inheritance chain efficiently using Django's batch_size.
@@ -672,18 +693,13 @@ class HookQuerySetMixin:
 
     def _process_mti_bulk_update_batch(
         self, batch, field_groups, inheritance_chain, **kwargs
-    ):
+    ) -> int:
         """
         Process a single batch of objects for MTI bulk update.
         Updates each table in the inheritance chain for the batch.
         """
         total_updated = 0
 
-        # For MTI, we need to handle parent links correctly
-        # The root model (first in chain) has its own PK
-        # Child models use the parent link to reference the root PK
-        root_model = inheritance_chain[0]
-
         # Get the primary keys from the objects
         # If objects have pk set but are not loaded from DB, use those PKs
         root_pks = []

{django_bulk_hooks-0.1.233 → django_bulk_hooks-0.1.234}/pyproject.toml

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