django-bulk-hooks 0.2.93__tar.gz → 0.2.103__tar.gz

{django_bulk_hooks-0.2.93 → django_bulk_hooks-0.2.103}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.93
+Version: 0.2.103
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.2.93 → django_bulk_hooks-0.2.103}/django_bulk_hooks/dispatcher.py

@@ -101,7 +101,9 @@ class HookDispatcher:
         hooks = self.registry.get_hooks(changeset.model_cls, event)
 
         logger.debug(f"🧵 DISPATCH: changeset.model_cls={changeset.model_cls.__name__}, event={event}")
-        logger.debug(f"🎣 HOOKS_FOUND: {len(hooks)} hooks for {changeset.model_cls.__name__}.{event}: {[f'{h[0].__name__}.{h[1]}' for h in hooks]}")
+        logger.debug(
+            f"🎣 HOOKS_FOUND: {len(hooks)} hooks for {changeset.model_cls.__name__}.{event}: {[f'{h[0].__name__}.{h[1]}' for h in hooks]}"
+        )
 
         if not hooks:
             return
@@ -125,11 +127,11 @@ class HookDispatcher:
             sorted_record_ids = tuple(record_ids)
 
         # Include changeset model and operation details to make the key more specific
-        operation_meta = getattr(changeset, 'operation_meta', {}) or {}
-        operation_type = getattr(changeset, 'operation_type', 'unknown')
+        operation_meta = getattr(changeset, "operation_meta", {}) or {}
+        operation_type = getattr(changeset, "operation_type", "unknown")
 
         # Include update_kwargs if present to distinguish different queryset operations
-        update_kwargs = operation_meta.get('update_kwargs', {})
+        update_kwargs = operation_meta.get("update_kwargs", {})
         if update_kwargs:
             try:
                 # Convert to a hashable representation
@@ -143,7 +145,7 @@ class HookDispatcher:
         operation_key = (event, changeset.model_cls.__name__, operation_type, sorted_record_ids, update_kwargs_key)
 
         # Track executed hooks to prevent duplicates in MTI inheritance chains
-        if not hasattr(self, '_executed_hooks'):
+        if not hasattr(self, "_executed_hooks"):
             self._executed_hooks = set()
 
         # Filter out hooks that have already been executed for this operation
@@ -224,7 +226,7 @@ class HookDispatcher:
                     )
 
                 # Mark that relationships have been preloaded to avoid duplicate condition preloading
-                changeset.operation_meta['relationships_preloaded'] = True
+                changeset.operation_meta["relationships_preloaded"] = True
                 logger.debug(f"🔗 @select_related: Preloaded relationships for {handler_cls.__name__}.{method_name}")
 
             except Exception as e:
@@ -239,9 +241,11 @@ class HookDispatcher:
         # NOW condition evaluation is safe - relationships are preloaded
         if condition:
             # Skip per-hook preloading if relationships were already preloaded upfront
-            if not changeset.operation_meta.get('relationships_preloaded', False):
+            if not changeset.operation_meta.get("relationships_preloaded", False):
                 condition_relationships = self._extract_condition_relationships(condition, changeset.model_cls)
-                logger.info(f"🔍 CONDITION: {handler_cls.__name__}.{method_name} has condition, extracted relationships: {condition_relationships}")
+                logger.info(
+                    f"🔍 CONDITION: {handler_cls.__name__}.{method_name} has condition, extracted relationships: {condition_relationships}"
+                )
                 if condition_relationships:
                     logger.info(f"🔗 PRELOADING: Preloading condition relationships for {len(changeset.changes)} records")
                     self._preload_condition_relationships(changeset, condition_relationships)
@@ -312,20 +316,20 @@ class HookDispatcher:
         relationships = set()
 
         # Guard against Mock objects and non-condition objects
-        if not hasattr(condition, 'check') or hasattr(condition, '_mock_name'):
+        if not hasattr(condition, "check") or hasattr(condition, "_mock_name"):
             return relationships
 
         # Handle different condition types
-        if hasattr(condition, 'field'):
+        if hasattr(condition, "field"):
             # Extract relationships from field path (e.g., "status__value" -> "status")
             field_path = condition.field
             if isinstance(field_path, str):
-                if '__' in field_path:
+                if "__" in field_path:
                     # Take the first part before __ (the relationship to preload)
-                    rel_field = field_path.split('__')[0]
+                    rel_field = field_path.split("__")[0]
 
                     # Normalize FK field names: business_id -> business
-                    if rel_field.endswith('_id'):
+                    if rel_field.endswith("_id"):
                         potential_field_name = rel_field[:-3]  # Remove '_id'
                         if self._is_relationship_field(model_cls, potential_field_name):
                             rel_field = potential_field_name
@@ -336,7 +340,7 @@ class HookDispatcher:
                     rel_field = field_path
 
                     # Normalize FK field names: business_id -> business
-                    if rel_field.endswith('_id'):
+                    if rel_field.endswith("_id"):
                         potential_field_name = rel_field[:-3]  # Remove '_id'
                         if self._is_relationship_field(model_cls, potential_field_name):
                             rel_field = potential_field_name
@@ -346,12 +350,12 @@ class HookDispatcher:
                         relationships.add(rel_field)
 
         # Handle composite conditions (AndCondition, OrCondition)
-        if hasattr(condition, 'cond1') and hasattr(condition, 'cond2'):
+        if hasattr(condition, "cond1") and hasattr(condition, "cond2"):
             relationships.update(self._extract_condition_relationships(condition.cond1, model_cls))
             relationships.update(self._extract_condition_relationships(condition.cond2, model_cls))
 
         # Handle NotCondition
-        if hasattr(condition, 'cond'):
+        if hasattr(condition, "cond"):
             relationships.update(self._extract_condition_relationships(condition.cond, model_cls))
 
         return relationships
@@ -403,9 +407,40 @@ class HookDispatcher:
                         preloaded_obj = preloaded[obj.pk]
                         for rel in relationship_list:
                             if hasattr(preloaded_obj, rel):
+                                # Preserve FK _id values in __dict__ before setattr (MTI fix)
+                                id_field_name = f"{rel}_id"
+                                field_was_in_dict = id_field_name in obj.__dict__
+                                preserved_id = obj.__dict__.get(id_field_name) if field_was_in_dict else None
+
+                                logger.debug("🔄 PRESERVE_FK_NEW: obj.pk=%s, %s in __dict__=%s, preserved=%s",
+                                           obj.pk, id_field_name, field_was_in_dict, preserved_id)
+
                                 setattr(obj, rel, getattr(preloaded_obj, rel))
 
+                                after_setattr = obj.__dict__.get(id_field_name, "NOT_IN_DICT")
+                                logger.debug("🔄 AFTER_SETATTR_NEW: obj.pk=%s, %s=%s (was %s)",
+                                           obj.pk, id_field_name, after_setattr, preserved_id)
+
+                                # Restore FK _id if it was in __dict__ (prevents Django descriptor from clearing it)
+                                # This includes restoring None if that's what was explicitly set
+                                if field_was_in_dict:
+                                    obj.__dict__[id_field_name] = preserved_id
+                                    # Also clear the relationship from fields_cache to prevent Django from
+                                    # returning the cached object when preserved_id is None
+                                    if preserved_id is None and hasattr(obj, "_state") and hasattr(obj._state, "fields_cache"):
+                                        if rel in obj._state.fields_cache:
+                                            obj._state.fields_cache.pop(rel, None)
+                                            logger.debug("🔄 CLEARED_CACHE: obj.pk=%s, cleared '%s' from fields_cache",
+                                                       obj.pk, rel)
+                                    logger.debug("🔄 RESTORED_FK_NEW: obj.pk=%s, %s=%s",
+                                               obj.pk, id_field_name, obj.__dict__.get(id_field_name))
+
             # Update old_records with preloaded relationships
+            # NOTE: We do NOT preserve/restore FK _id values for old_records because:
+            # 1. old_records represent the "before" state for hook conditions
+            # 2. They should reflect database values, not in-memory user changes
+            # 3. When new_records and old_records share the same object instances,
+            #    restoring DB values here would overwrite user's in-memory changes
             if changeset.old_records:
                 for obj in changeset.old_records:
                     if obj.pk and obj.pk in preloaded:
@@ -414,6 +449,13 @@ class HookDispatcher:
                             if hasattr(preloaded_obj, rel):
                                 setattr(obj, rel, getattr(preloaded_obj, rel))
 
+        # Log final state after preloading
+        if changeset.new_records:
+            for obj in changeset.new_records:
+                if "business_id" in obj.__dict__:
+                    logger.debug("🔄 FINAL_STATE_NEW: obj.pk=%s, business_id=%s",
+                               obj.pk, obj.__dict__.get("business_id"))
+
         # Handle unsaved new_records by preloading their FK targets (bulk query to avoid N+1)
         if changeset.new_records:
             # Collect FK IDs for each relationship from unsaved records
@@ -422,8 +464,8 @@ class HookDispatcher:
             for obj in changeset.new_records:
                 if obj.pk is None:  # Unsaved object
                     for rel in relationship_list:
-                        if hasattr(obj, f'{rel}_id'):
-                            rel_id = getattr(obj, f'{rel}_id')
+                        if hasattr(obj, f"{rel}_id"):
+                            rel_id = getattr(obj, f"{rel}_id")
                             if rel_id:
                                 field_ids_map[rel].add(rel_id)
 
@@ -433,7 +475,7 @@ class HookDispatcher:
                 if not ids:
                     continue
                 try:
-                    rel_model = getattr(changeset.model_cls._meta.get_field(rel).remote_field, 'model')
+                    rel_model = getattr(changeset.model_cls._meta.get_field(rel).remote_field, "model")
                     field_objects_map[rel] = rel_model.objects.in_bulk(ids)
                 except Exception:
                     field_objects_map[rel] = {}
@@ -442,12 +484,26 @@ class HookDispatcher:
             for obj in changeset.new_records:
                 if obj.pk is None:  # Unsaved object
                     for rel in relationship_list:
-                        rel_id = getattr(obj, f'{rel}_id', None)
+                        rel_id = getattr(obj, f"{rel}_id", None)
                         if rel_id and rel in field_objects_map:
                             rel_obj = field_objects_map[rel].get(rel_id)
                             if rel_obj:
+                                # Preserve FK _id value before setattr (MTI/upsert fix)
+                                id_field_name = f"{rel}_id"
+                                field_was_in_dict = id_field_name in obj.__dict__
+                                preserved_id = obj.__dict__.get(id_field_name) if field_was_in_dict else None
+
+                                logger.debug("🔄 PRESERVE_FK_UNSAVED: obj.pk=%s, %s in __dict__=%s, preserved=%s",
+                                           obj.pk, id_field_name, field_was_in_dict, preserved_id)
+
                                 setattr(obj, rel, rel_obj)
 
+                                # Restore FK _id if it was in __dict__ (prevents Django descriptor from clearing it)
+                                if field_was_in_dict and preserved_id is not None:
+                                    obj.__dict__[id_field_name] = preserved_id
+                                    logger.debug("🔄 RESTORED_FK_UNSAVED: obj.pk=%s, %s=%s",
+                                               obj.pk, id_field_name, obj.__dict__.get(id_field_name))
+
     def _preload_select_related_for_before_create(self, changeset, select_related_fields):
         """
         Explicit bulk preloading for @select_related on BEFORE_CREATE hooks.
@@ -462,7 +518,7 @@ class HookDispatcher:
             select_related_fields: List of field names to preload (e.g., ['financial_account'])
         """
         # Ensure select_related_fields is actually iterable (not a Mock in tests)
-        if not select_related_fields or not changeset.new_records or not hasattr(select_related_fields, '__iter__'):
+        if not select_related_fields or not changeset.new_records or not hasattr(select_related_fields, "__iter__"):
             return
 
         logger.info(f"🔗 BULK PRELOAD: Preloading {select_related_fields} for {len(changeset.new_records)} unsaved records")
@@ -472,7 +528,7 @@ class HookDispatcher:
 
         for record in changeset.new_records:
             for field in select_related_fields:
-                fk_id = getattr(record, f'{field}_id', None)
+                fk_id = getattr(record, f"{field}_id", None)
                 if fk_id is not None:
                     field_ids_map[field].add(fk_id)
 
@@ -501,13 +557,23 @@ class HookDispatcher:
         # Attach relationships to each record
         for record in changeset.new_records:
             for field in select_related_fields:
-                fk_id = getattr(record, f'{field}_id', None)
+                fk_id = getattr(record, f"{field}_id", None)
                 if fk_id is not None and field in field_objects_map:
                     related_obj = field_objects_map[field].get(fk_id)
                     if related_obj is not None:
+                        # Preserve FK _id value before setattr (MTI/upsert fix)
+                        id_field_name = f"{field}_id"
+                        field_was_in_dict = id_field_name in record.__dict__
+                        preserved_id = record.__dict__.get(id_field_name) if field_was_in_dict else None
+
                         setattr(record, field, related_obj)
+
+                        # Restore FK _id if it was in __dict__ (prevents Django descriptor from clearing it)
+                        if field_was_in_dict and preserved_id is not None:
+                            record.__dict__[id_field_name] = preserved_id
+
                         # Also cache in Django's fields_cache for consistency
-                        if hasattr(record, '_state') and hasattr(record._state, 'fields_cache'):
+                        if hasattr(record, "_state") and hasattr(record._state, "fields_cache"):
                             record._state.fields_cache[field] = related_obj
 
         logger.info(f"🔗 BULK PRELOAD: Completed relationship attachment for {len(changeset.new_records)} records")

{django_bulk_hooks-0.2.93 → django_bulk_hooks-0.2.103}/django_bulk_hooks/operations/bulk_executor.py

@@ -150,6 +150,13 @@ class BulkExecutor:
         if not objs:
             return 0
 
+        # Debug: Check FK values at bulk_update entry point
+        for obj in objs:
+            logger.debug("🚀 BULK_UPDATE_ENTRY: obj.pk=%s, business_id in __dict__=%s, value=%s",
+                        getattr(obj, 'pk', 'None'),
+                        'business_id' in obj.__dict__,
+                        obj.__dict__.get('business_id', 'NOT_IN_DICT'))
+
         # Ensure auto_now fields are included
         fields = self._add_auto_now_fields(fields, objs)
 
@@ -674,6 +681,14 @@ class BulkExecutor:
 
         logger.debug(f"Building CASE statements for {field_group.model_class.__name__} with {len(field_group.fields)} fields")
 
+        # Debug: Check if business_id is still in __dict__ before field extraction
+        for obj in objs:
+            if 'business_id' in obj.__dict__ or 'business' in field_group.fields:
+                logger.debug("🏗️ CASE_BUILD_START: obj.pk=%s, business_id in __dict__=%s, value=%s",
+                            getattr(obj, 'pk', 'None'),
+                            'business_id' in obj.__dict__,
+                            obj.__dict__.get('business_id', 'NOT_IN_DICT'))
+
         for field_name in field_group.fields:
             case_stmt = self._build_field_case_statement(field_name, field_group, root_pks, objs)
             if case_stmt:
@@ -699,6 +714,13 @@ class BulkExecutor:
 
             # Get and convert field value
             value = get_field_value_for_db(obj, field_name, field_group.model_class)
+            
+            # Debug: Track business field extraction
+            if field_name == 'business':
+                logger.debug("🔧 CASE_FIELD_VALUE: obj.pk=%s, field='%s', raw_value=%s, business_id in __dict__=%s",
+                           obj_pk, field_name, value,
+                           'business_id' in obj.__dict__ if hasattr(obj, '__dict__') else 'N/A')
+            
             value = field.to_python(value)
 
             # Create WHEN with type casting
@@ -722,6 +744,7 @@ class BulkExecutor:
     ) -> int:
         """Execute the actual update query."""
         logger.debug(f"Executing update for {field_group.model_class.__name__} with {len(case_statements)} fields")
+        logger.debug(f"📝 UPDATE_FIELDS: {field_group.model_class.__name__} updating fields: {list(case_statements.keys())}")
 
         try:
             query_qs = base_qs.filter(**{f"{field_group.filter_field}__in": root_pks})

{django_bulk_hooks-0.2.93 → django_bulk_hooks-0.2.103}/django_bulk_hooks/operations/field_utils.py

@@ -70,9 +70,15 @@ def _extract_fk_value(obj, field_name, field, model_cls):
                  attname, field_was_explicitly_set, list(obj.__dict__.keys()))
 
     # Try direct access first
-    value = getattr(obj, attname, None)
-    logger.debug("🔍 FK_DIRECT_ACCESS: getattr(obj, '%s') = %s (type: %s)",
-                 attname, value, type(value).__name__ if value is not None else 'None')
+    # For MTI scenarios, try __dict__ first to avoid Django descriptor database lookups
+    if obj.__class__ != model_cls and attname in obj.__dict__:
+        value = obj.__dict__[attname]
+        logger.debug("🔍 FK_DIRECT_ACCESS_DICT: obj.__dict__['%s'] = %s (type: %s) [MTI bypass]",
+                     attname, value, type(value).__name__ if value is not None else 'None')
+    else:
+        value = getattr(obj, attname, None)
+        logger.debug("🔍 FK_DIRECT_ACCESS: getattr(obj, '%s') = %s (type: %s)",
+                     attname, value, type(value).__name__ if value is not None else 'None')
 
     # For MTI scenarios where parent field access fails on child instance
     # OR when the _id field is None but the relationship field is set (common in MTI)

{django_bulk_hooks-0.2.93 → django_bulk_hooks-0.2.103}/django_bulk_hooks/operations/mti_handler.py

@@ -165,6 +165,9 @@ class MTIHandler:
         batch_size = batch_size or len(objs)
         existing_record_ids = existing_record_ids or set()
         existing_pks_map = existing_pks_map or {}
+        
+        logger.debug("🔧 MTI_CREATE_PLAN: model=%s, update_conflicts=%s, unique_fields=%s, update_fields=%s",
+                   self.model_cls.__name__, update_conflicts, unique_fields, update_fields)
 
         # Set PKs on existing objects for proper updates
         self._set_existing_pks(objs, existing_pks_map)
@@ -410,7 +413,13 @@ class MTIHandler:
         update_fields: Optional[List[str]],
     ) -> Dict[str, any]:
         """Build upsert config for levels with matching unique constraints."""
+        logger.debug("🔧 UPSERT_CONFIG: model=%s, incoming_update_fields=%s, local_fields=%s",
+                   model_class.__name__, update_fields, list(model_fields_by_name.keys()))
+        
         filtered_updates = [uf for uf in (update_fields or []) if uf in model_fields_by_name]
+        
+        logger.debug("🔧 UPSERT_FILTERED: model=%s, filtered_update_fields=%s",
+                   model_class.__name__, filtered_updates)
 
         # Add auto_now fields (critical for timestamp updates)
         auto_now_fields = self._get_auto_now_fields(model_class, model_fields_by_name)

{django_bulk_hooks-0.2.93 → django_bulk_hooks-0.2.103}/pyproject.toml

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