django-bulk-hooks 0.2.44__tar.gz → 0.2.46__tar.gz

{django_bulk_hooks-0.2.44 → django_bulk_hooks-0.2.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.44
+Version: 0.2.46
 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.44 → django_bulk_hooks-0.2.46}/django_bulk_hooks/operations/analyzer.py

@@ -77,14 +77,11 @@ class ModelAnalyzer:
         if not objs:
             return
 
-        invalid_types = {
-            type(obj).__name__ for obj in objs if not isinstance(obj, self.model_cls)
-        }
+        invalid_types = {type(obj).__name__ for obj in objs if not isinstance(obj, self.model_cls)}
 
         if invalid_types:
             raise TypeError(
-                f"{operation} expected instances of {self.model_cls.__name__}, "
-                f"but got {invalid_types}",
+                f"{operation} expected instances of {self.model_cls.__name__}, but got {invalid_types}",
             )
 
     def _check_has_pks(self, objs, operation="operation"):
@@ -130,7 +127,9 @@ class ModelAnalyzer:
         auto_now_fields = []
         for field in self.model_cls._meta.fields:
             if getattr(field, "auto_now", False) or getattr(
-                field, "auto_now_add", False,
+                field,
+                "auto_now_add",
+                False,
             ):
                 auto_now_fields.append(field.name)
         return auto_now_fields
@@ -142,11 +141,7 @@ class ModelAnalyzer:
         Returns:
             list: FK field names
         """
-        return [
-            field.name
-            for field in self.model_cls._meta.concrete_fields
-            if field.is_relation and not field.many_to_many
-        ]
+        return [field.name for field in self.model_cls._meta.concrete_fields if field.is_relation and not field.many_to_many]
 
     def detect_changed_fields(self, objs):
         """
@@ -210,15 +205,15 @@ class ModelAnalyzer:
     def resolve_expression(self, field_name, expression, instance):
         """
         Resolve a SQL expression to a concrete value for a specific instance.
-        
+
         This method materializes database expressions (F(), Subquery, Case, etc.)
         into concrete values by using Django's annotate() mechanism.
-        
+
         Args:
             field_name: Name of the field being updated
             expression: The expression or value to resolve
             instance: The model instance to resolve for
-            
+
         Returns:
             The resolved concrete value
         """
@@ -236,31 +231,34 @@ class ModelAnalyzer:
             instance_qs = self.model_cls.objects.filter(pk=instance.pk)
 
             # Use annotate with the expression and let Django resolve it
-            resolved_value = instance_qs.annotate(
-                _resolved_value=expression,
-            ).values_list("_resolved_value", flat=True).first()
+            resolved_value = (
+                instance_qs.annotate(
+                    _resolved_value=expression,
+                )
+                .values_list("_resolved_value", flat=True)
+                .first()
+            )
 
             return resolved_value
         except Exception as e:
             # If expression resolution fails, log and return original
             logger.warning(
-                f"Failed to resolve expression for field '{field_name}' "
-                f"on {self.model_cls.__name__}: {e}. Using original value.",
+                f"Failed to resolve expression for field '{field_name}' on {self.model_cls.__name__}: {e}. Using original value.",
             )
             return expression
 
     def apply_update_values(self, instances, update_kwargs):
         """
         Apply update_kwargs to instances, resolving any SQL expressions.
-        
+
         This method transforms queryset.update()-style kwargs (which may contain
         F() expressions, Subquery, Case, etc.) into concrete values and applies
         them to the instances.
-        
+
         Args:
             instances: List of model instances to update
             update_kwargs: Dict of {field_name: value_or_expression}
-            
+
         Returns:
             List of field names that were updated
         """
@@ -271,7 +269,7 @@ class ModelAnalyzer:
             return []
 
         fields_updated = list(update_kwargs.keys())
-        
+
         # Extract PKs
         pks = [inst.pk for inst in instances if inst.pk is not None]
         if not pks:
@@ -306,8 +304,7 @@ class ModelAnalyzer:
             except Exception as e:
                 # If expression resolution fails, log and use original
                 logger.warning(
-                    f"Failed to resolve expression for field '{field_name}' "
-                    f"on {self.model_cls.__name__}: {e}. Using original value.",
+                    f"Failed to resolve expression for field '{field_name}' on {self.model_cls.__name__}: {e}. Using original value.",
                 )
                 for instance in instances:
                     setattr(instance, field_name, value)

{django_bulk_hooks-0.2.44 → django_bulk_hooks-0.2.46}/django_bulk_hooks/operations/bulk_executor.py

@@ -74,7 +74,6 @@ class BulkExecutor:
 
         # Check if this is an MTI model and route accordingly
         if self.mti_handler.is_mti_model():
-            logger.info(f"Detected MTI model {self.model_cls.__name__}, using MTI bulk create")
 
             # Use pre-classified records if provided, otherwise classify now
             if existing_record_ids is None or existing_pks_map is None:
@@ -82,6 +81,9 @@ class BulkExecutor:
                 existing_pks_map = {}
                 if update_conflicts and unique_fields:
                     existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(objs, unique_fields)
+                    logger.info(f"MTI Upsert classification: {len(existing_record_ids)} existing, {len(objs) - len(existing_record_ids)} new")
+                    logger.info(f"existing_record_ids: {existing_record_ids}")
+                    logger.info(f"existing_pks_map: {existing_pks_map}")
 
             # Build execution plan with classification results
             plan = self.mti_handler.build_create_plan(
@@ -95,11 +97,11 @@ class BulkExecutor:
             )
             # Execute the plan
             result = self._execute_mti_create_plan(plan)
-            
+
             # Tag objects with upsert metadata for hook dispatching
             if update_conflicts and unique_fields:
                 self._tag_upsert_metadata(result, existing_record_ids)
-            
+
             return result
 
         # Non-MTI model - use Django's native bulk_create
@@ -112,14 +114,14 @@ class BulkExecutor:
             unique_fields,
             **kwargs,
         )
-        
+
         # Tag objects with upsert metadata for hook dispatching
         if update_conflicts and unique_fields:
             # Use pre-classified results if available, otherwise classify now
             if existing_record_ids is None:
                 existing_record_ids, _ = self.record_classifier.classify_for_upsert(objs, unique_fields)
             self._tag_upsert_metadata(result, existing_record_ids)
-        
+
         return result
 
     def _execute_bulk_create(
@@ -205,59 +207,41 @@ class BulkExecutor:
         if not plan:
             return []
 
+
         with transaction.atomic(using=self.queryset.db, savepoint=False):
-            # Step 1: Create/Update all parent objects level by level
+            # Step 1: Upsert all parent objects level by level using Django's native upsert
             parent_instances_map = {}  # Maps original obj id() -> {model: parent_instance}
 
             for parent_level in plan.parent_levels:
-                # Separate new and existing parent objects
-                new_parents = []
-                existing_parents = []
-
-                for parent_obj in parent_level.objects:
-                    orig_obj_id = parent_level.original_object_map[id(parent_obj)]
-                    if orig_obj_id in plan.existing_record_ids:
-                        existing_parents.append(parent_obj)
-                    else:
-                        new_parents.append(parent_obj)
-
-                # Bulk create new parents
-                if new_parents:
-                    bulk_kwargs = {"batch_size": len(new_parents)}
-
-                    if parent_level.update_conflicts:
-                        bulk_kwargs["update_conflicts"] = True
-                        bulk_kwargs["unique_fields"] = parent_level.unique_fields
-                        bulk_kwargs["update_fields"] = parent_level.update_fields
-
-                    # Use base QuerySet to avoid recursion
-                    base_qs = BaseQuerySet(model=parent_level.model_class, using=self.queryset.db)
-                    created_parents = base_qs.bulk_create(new_parents, **bulk_kwargs)
-
-                    # Copy generated fields back to parent objects
-                    for created_parent, parent_obj in zip(created_parents, new_parents):
-                        for field in parent_level.model_class._meta.local_fields:
-                            created_value = getattr(created_parent, field.name, None)
-                            if created_value is not None:
-                                setattr(parent_obj, field.name, created_value)
-
-                        parent_obj._state.adding = False
-                        parent_obj._state.db = self.queryset.db
-
-                # Update existing parents
-                if existing_parents and parent_level.update_fields:
+                # Use base QuerySet to avoid recursion
+                base_qs = BaseQuerySet(model=parent_level.model_class, using=self.queryset.db)
+                
+                # Build bulk_create kwargs
+                bulk_kwargs = {"batch_size": len(parent_level.objects)}
+                
+                if parent_level.update_conflicts:
+                    # Let Django handle the upsert - it will INSERT or UPDATE as needed
+                    bulk_kwargs["update_conflicts"] = True
+                    bulk_kwargs["unique_fields"] = parent_level.unique_fields
+                    
                     # Filter update fields to only those that exist in this parent model
                     parent_model_fields = {field.name for field in parent_level.model_class._meta.local_fields}
                     filtered_update_fields = [field for field in parent_level.update_fields if field in parent_model_fields]
-
                     if filtered_update_fields:
-                        base_qs = BaseQuerySet(model=parent_level.model_class, using=self.queryset.db)
-                        base_qs.bulk_update(existing_parents, filtered_update_fields)
+                        bulk_kwargs["update_fields"] = filtered_update_fields
+
+                # Perform the upsert - Django handles INSERT vs UPDATE automatically
+                upserted_parents = base_qs.bulk_create(parent_level.objects, **bulk_kwargs)
+
+                # Copy generated fields back to parent objects
+                for upserted_parent, parent_obj in zip(upserted_parents, parent_level.objects):
+                    for field in parent_level.model_class._meta.local_fields:
+                        upserted_value = getattr(upserted_parent, field.name, None)
+                        if upserted_value is not None:
+                            setattr(parent_obj, field.name, upserted_value)
 
-                    # Mark as not adding
-                    for parent_obj in existing_parents:
-                        parent_obj._state.adding = False
-                        parent_obj._state.db = self.queryset.db
+                    parent_obj._state.adding = False
+                    parent_obj._state.db = self.queryset.db
 
                 # Map parents back to original objects
                 for parent_obj in parent_level.objects:
@@ -266,10 +250,7 @@ class BulkExecutor:
                         parent_instances_map[orig_obj_id] = {}
                     parent_instances_map[orig_obj_id][parent_level.model_class] = parent_obj
 
-            # Step 2: Add parent links to child objects and separate new/existing
-            new_child_objects = []
-            existing_child_objects = []
-
+            # Step 2: Add parent links to child objects and set PKs for existing records
             for child_obj, orig_obj in zip(plan.child_objects, plan.original_objects):
                 parent_instances = parent_instances_map.get(id(orig_obj), {})
 
@@ -279,91 +260,81 @@ class BulkExecutor:
                     if parent_link:
                         setattr(child_obj, parent_link.attname, parent_instance.pk)
                         setattr(child_obj, parent_link.name, parent_instance)
+                        # IMPORTANT: Don't set the child's PK here - it should only get PK after insertion
+                        # The parent link field (hookmodel_ptr) is NOT the same as the child's PK
+                    else:
+                        logger.warning(f"No parent link found for {parent_model} in {plan.child_model}")
 
-                # Classify as new or existing
+                # For existing records in upsert, ensure PK is set on child object
                 if id(orig_obj) in plan.existing_record_ids:
-                    # For existing records, set the PK on child object
                     pk_value = getattr(orig_obj, "pk", None)
                     if pk_value:
                         child_obj.pk = pk_value
                         child_obj.id = pk_value
-                    existing_child_objects.append(child_obj)
-                else:
-                    new_child_objects.append(child_obj)
-
-            # Step 3: Bulk create new child objects using _batched_insert (to bypass MTI check)
-            if new_child_objects:
-                base_qs = BaseQuerySet(model=plan.child_model, using=self.queryset.db)
-                base_qs._prepare_for_bulk_create(new_child_objects)
-
-                # Partition objects by PK status
-                objs_without_pk, objs_with_pk = [], []
-                for obj in new_child_objects:
-                    if obj._is_pk_set():
-                        objs_with_pk.append(obj)
                     else:
-                        objs_without_pk.append(obj)
+                        # If no PK on original object, this is a new record, don't set PK
+                        logger.info(f"New record {orig_obj} - not setting PK on child object")
 
-                # Get fields for insert
-                opts = plan.child_model._meta
-                fields = [f for f in opts.local_fields if not f.generated]
-
-                # Execute bulk insert
-                if objs_with_pk:
-                    returned_columns = base_qs._batched_insert(
-                        objs_with_pk,
-                        fields,
-                        batch_size=len(objs_with_pk),
-                    )
-                    if returned_columns:
-                        for obj, results in zip(objs_with_pk, returned_columns):
-                            if hasattr(opts, "db_returning_fields") and hasattr(opts, "pk"):
-                                for result, field in zip(results, opts.db_returning_fields):
-                                    if field != opts.pk:
-                                        setattr(obj, field.attname, result)
-                            obj._state.adding = False
-                            obj._state.db = self.queryset.db
-                    else:
-                        for obj in objs_with_pk:
-                            obj._state.adding = False
-                            obj._state.db = self.queryset.db
-
-                if objs_without_pk:
-                    filtered_fields = [f for f in fields if not isinstance(f, AutoField) and not f.primary_key]
-                    returned_columns = base_qs._batched_insert(
-                        objs_without_pk,
-                        filtered_fields,
-                        batch_size=len(objs_without_pk),
-                    )
-                    if returned_columns:
-                        for obj, results in zip(objs_without_pk, returned_columns):
-                            if hasattr(opts, "db_returning_fields"):
-                                for result, field in zip(results, opts.db_returning_fields):
-                                    setattr(obj, field.attname, result)
-                            obj._state.adding = False
-                            obj._state.db = self.queryset.db
-                    else:
-                        for obj in objs_without_pk:
-                            obj._state.adding = False
-                            obj._state.db = self.queryset.db
+            # Step 3: Handle child objects
+            # Note: We can't use bulk_create on child MTI models, so we use _batched_insert for new records
+            # and bulk_update for existing records
+            base_qs = BaseQuerySet(model=plan.child_model, using=self.queryset.db)
+            
+            # For MTI child objects, we need to handle them differently
+            # In MTI, child objects get PKs from parent links, but we need to distinguish
+            # between truly new records and existing records for upsert operations
+            objs_without_pk, objs_with_pk = [], []
+            for child_obj, orig_obj in zip(plan.child_objects, plan.original_objects):
+                # Check if this is an existing record (for upsert operations)
+                if id(orig_obj) in plan.existing_record_ids:
+                    # Existing record - should be updated
+                    objs_with_pk.append(child_obj)
+                else:
+                    # New record - should be inserted
+                    objs_without_pk.append(child_obj)
 
-            # Step 3.5: Update existing child objects
-            if existing_child_objects and plan.update_fields:
+            # For objects with PK (existing records in upsert), use bulk_update
+            if objs_with_pk and plan.update_fields:
                 # Filter update fields to only those that exist in the child model
                 child_model_fields = {field.name for field in plan.child_model._meta.local_fields}
                 filtered_child_update_fields = [field for field in plan.update_fields if field in child_model_fields]
 
                 if filtered_child_update_fields:
-                    base_qs = BaseQuerySet(model=plan.child_model, using=self.queryset.db)
-                    base_qs.bulk_update(existing_child_objects, filtered_child_update_fields)
+                    base_qs.bulk_update(objs_with_pk, filtered_child_update_fields)
 
                 # Mark as not adding
-                for child_obj in existing_child_objects:
-                    child_obj._state.adding = False
-                    child_obj._state.db = self.queryset.db
+                for obj in objs_with_pk:
+                    obj._state.adding = False
+                    obj._state.db = self.queryset.db
 
-            # Combine all children for final processing
-            created_children = new_child_objects + existing_child_objects
+            # For objects without PK (new records), use _batched_insert
+            if objs_without_pk:
+                base_qs._prepare_for_bulk_create(objs_without_pk)
+                opts = plan.child_model._meta
+                
+                # Include all local fields except auto-generated ones
+                # For MTI, we need to include the parent link (which is the PK)
+                filtered_fields = [f for f in opts.local_fields if not f.generated]
+                
+                returned_columns = base_qs._batched_insert(
+                    objs_without_pk,
+                    filtered_fields,
+                    batch_size=len(objs_without_pk),
+                )
+                if returned_columns:
+                    for obj, results in zip(objs_without_pk, returned_columns):
+                        if hasattr(opts, "db_returning_fields"):
+                            for result, field in zip(results, opts.db_returning_fields):
+                                setattr(obj, field.attname, result)
+                        obj._state.adding = False
+                        obj._state.db = self.queryset.db
+                else:
+                    for obj in objs_without_pk:
+                        obj._state.adding = False
+                        obj._state.db = self.queryset.db
+
+            # All child objects are now created/updated
+            created_children = plan.child_objects
 
             # Step 4: Copy PKs and auto-generated fields back to original objects
             pk_field_name = plan.child_model._meta.pk.name
@@ -532,16 +503,30 @@ class BulkExecutor:
     def _tag_upsert_metadata(self, result_objects, existing_record_ids):
         """
         Tag objects with metadata indicating whether they were created or updated.
-        
+
         This metadata is used by the coordinator to determine which hooks to fire.
         The metadata is temporary and will be cleaned up after hook execution.
-        
+
         Args:
             result_objects: List of objects returned from bulk operation
             existing_record_ids: Set of id() for objects that existed before the operation
         """
+        created_count = 0
+        updated_count = 0
+
         for obj in result_objects:
             # Tag with metadata for hook dispatching
             was_created = id(obj) not in existing_record_ids
             obj._bulk_hooks_was_created = was_created
             obj._bulk_hooks_upsert_metadata = True
+
+            if was_created:
+                created_count += 1
+            else:
+                updated_count += 1
+
+        logger.info(
+            f"Tagged upsert metadata: {created_count} created, {updated_count} updated "
+            f"(total={len(result_objects)}, existing_ids={len(existing_record_ids)})"
+        )
+

{django_bulk_hooks-0.2.44 → django_bulk_hooks-0.2.46}/django_bulk_hooks/operations/coordinator.py

@@ -29,7 +29,6 @@ class BulkOperationCoordinator:
     Services are created lazily and cached.
     """
 
-
     def __init__(self, queryset):
         """
         Initialize coordinator for a queryset.
@@ -137,13 +136,10 @@ class BulkOperationCoordinator:
         existing_record_ids = set()
         existing_pks_map = {}
         if update_conflicts and unique_fields:
-            existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(
-                objs, unique_fields
-            )
-            logger.info(
-                f"Upsert operation: {len(existing_record_ids)} existing, "
-                f"{len(objs) - len(existing_record_ids)} new records"
-            )
+            existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(objs, unique_fields)
+            logger.info(f"Upsert operation: {len(existing_record_ids)} existing, {len(objs) - len(existing_record_ids)} new records")
+            logger.debug(f"Existing record IDs: {existing_record_ids}")
+            logger.debug(f"Existing PKs map: {existing_pks_map}")
 
         # Build initial changeset
         changeset = build_changeset_for_create(
@@ -236,14 +232,17 @@ class BulkOperationCoordinator:
 
     @transaction.atomic
     def update_queryset(
-        self, update_kwargs, bypass_hooks=False, bypass_validation=False,
+        self,
+        update_kwargs,
+        bypass_hooks=False,
+        bypass_validation=False,
     ):
         """
         Execute queryset.update() with full hook support.
-        
+
         ARCHITECTURE & PERFORMANCE TRADE-OFFS
         ======================================
-        
+
         To support hooks with queryset.update(), we must:
         1. Fetch old state (SELECT all matching rows)
         2. Execute database update (UPDATE in SQL)
@@ -252,29 +251,29 @@ class BulkOperationCoordinator:
         5. Run BEFORE_UPDATE hooks (CAN modify instances)
         6. Persist BEFORE_UPDATE modifications (bulk_update)
         7. Run AFTER_UPDATE hooks (read-only side effects)
-        
+
         Performance Cost:
         - 2 SELECT queries (before/after)
         - 1 UPDATE query (actual update)
         - 1 bulk_update (if hooks modify data)
-        
+
         Trade-off: Hooks require loading data into Python. If you need
         maximum performance and don't need hooks, use bypass_hooks=True.
-        
+
         Hook Semantics:
         - BEFORE_UPDATE hooks run after the DB update and CAN modify instances
         - Modifications are auto-persisted (framework handles complexity)
         - AFTER_UPDATE hooks run after BEFORE_UPDATE and are read-only
         - This enables cascade logic and computed fields based on DB values
         - User expectation: BEFORE_UPDATE hooks can modify data
-        
+
         Why this approach works well:
         - Allows hooks to see Subquery/F() computed values
         - Enables HasChanged conditions on complex expressions
         - Maintains SQL performance (Subquery stays in database)
         - Meets user expectations: BEFORE_UPDATE can modify instances
         - Clean separation: BEFORE for modifications, AFTER for side effects
-        
+
         For true "prevent write" semantics, intercept at a higher level
         or use bulk_update() directly (which has true before semantics).
         """
@@ -291,19 +290,21 @@ class BulkOperationCoordinator:
         )
 
     def _execute_queryset_update_with_hooks(
-        self, update_kwargs, bypass_validation=False,
+        self,
+        update_kwargs,
+        bypass_validation=False,
     ):
         """
         Execute queryset update with full hook lifecycle support.
-        
+
         This method implements the fetch-update-fetch pattern required
         to support hooks with queryset.update(). BEFORE_UPDATE hooks can
         modify instances and modifications are auto-persisted.
-        
+
         Args:
             update_kwargs: Dict of fields to update
             bypass_validation: Skip validation hooks if True
-            
+
         Returns:
             Number of rows updated
         """
@@ -387,11 +388,11 @@ class BulkOperationCoordinator:
     def _run_before_update_hooks_with_tracking(self, instances, models_in_chain, changeset):
         """
         Run BEFORE_UPDATE hooks and detect modifications.
-        
+
         This is what users expect - BEFORE_UPDATE hooks can modify instances
         and those modifications will be automatically persisted. The framework
         handles the complexity internally.
-        
+
         Returns:
             Set of field names that were modified by hooks
         """
@@ -413,10 +414,10 @@ class BulkOperationCoordinator:
     def _snapshot_instance_state(self, instances):
         """
         Create a snapshot of current instance field values.
-        
+
         Args:
             instances: List of model instances
-            
+
         Returns:
             Dict mapping pk -> {field_name: value}
         """
@@ -446,11 +447,11 @@ class BulkOperationCoordinator:
     def _detect_modifications(self, instances, pre_hook_state):
         """
         Detect which fields were modified by comparing to snapshot.
-        
+
         Args:
             instances: List of model instances
             pre_hook_state: Previous state snapshot from _snapshot_instance_state
-            
+
         Returns:
             Set of field names that were modified
         """
@@ -477,16 +478,15 @@ class BulkOperationCoordinator:
     def _persist_hook_modifications(self, instances, modified_fields):
         """
         Persist modifications made by hooks using bulk_update.
-        
+
         This creates a "cascade" effect similar to Salesforce workflows.
-        
+
         Args:
             instances: List of modified instances
             modified_fields: Set of field names that were modified
         """
         logger.info(
-            f"Hooks modified {len(modified_fields)} field(s): "
-            f"{', '.join(sorted(modified_fields))}",
+            f"Hooks modified {len(modified_fields)} field(s): {', '.join(sorted(modified_fields))}",
         )
         logger.info("Auto-persisting modifications via bulk_update")
 
@@ -569,14 +569,14 @@ class BulkOperationCoordinator:
     def _build_changeset_for_model(self, original_changeset, target_model_cls):
         """
         Build a changeset for a specific model in the MTI inheritance chain.
-        
+
         This allows parent model hooks to receive the same instances but with
         the correct model_cls for hook registration matching.
-        
+
         Args:
             original_changeset: The original changeset (for child model)
             target_model_cls: The model class to build changeset for (parent model)
-            
+
         Returns:
             ChangeSet for the target model
         """
@@ -600,18 +600,18 @@ class BulkOperationCoordinator:
     ):
         """
         Execute operation with hooks for entire MTI inheritance chain.
-        
+
         This method dispatches hooks for both child and parent models when
         dealing with MTI models, ensuring parent model hooks fire when
         child instances are created/updated/deleted.
-        
+
         Args:
             changeset: ChangeSet for the child model
             operation: Callable that performs the actual DB operation
             event_prefix: 'create', 'update', or 'delete'
             bypass_hooks: Skip all hooks if True
             bypass_validation: Skip validation hooks if True
-            
+
         Returns:
             Result of operation
         """
@@ -649,8 +649,9 @@ class BulkOperationCoordinator:
             else:
                 # Normal create operation
                 from django_bulk_hooks.helpers import build_changeset_for_create
+
                 changeset = build_changeset_for_create(changeset.model_cls, result)
-                
+
                 for model_cls in models_in_chain:
                     model_changeset = self._build_changeset_for_model(changeset, model_cls)
                     self.dispatcher.dispatch(model_changeset, f"after_{event_prefix}", bypass_hooks=False)
@@ -680,11 +681,13 @@ class BulkOperationCoordinator:
         for field_name in update_kwargs.keys():
             try:
                 field = self.model_cls._meta.get_field(field_name)
-                if (field.is_relation and
-                    not field.many_to_many and
-                    not field.one_to_many and
-                    hasattr(field, "attname") and
-                    field.attname == field_name):
+                if (
+                    field.is_relation
+                    and not field.many_to_many
+                    and not field.one_to_many
+                    and hasattr(field, "attname")
+                    and field.attname == field_name
+                ):
                     # This is a FK field being updated by its attname (e.g., business_id)
                     # Add the relationship name (e.g., 'business') to skip list
                     fk_relationships.add(field.name)
@@ -696,86 +699,114 @@ class BulkOperationCoordinator:
 
     def _is_upsert_operation(self, result_objects):
         """
-        Check if the operation was an upsert (mixed create/update).
-        
+        Check if the operation was an upsert (with update_conflicts=True).
+
         Args:
             result_objects: List of objects returned from the operation
-            
+
         Returns:
             True if this was an upsert operation, False otherwise
         """
         if not result_objects:
             return False
-            
+
         # Check if any object has upsert metadata
-        return hasattr(result_objects[0], '_bulk_hooks_upsert_metadata')
+        return hasattr(result_objects[0], "_bulk_hooks_upsert_metadata")
 
     def _dispatch_upsert_after_hooks(self, result_objects, models_in_chain):
         """
         Dispatch after hooks for upsert operations, splitting by create/update.
-        
+
         This matches Salesforce behavior:
         - Records that were created fire after_create hooks
         - Records that were updated fire after_update hooks
-        
+
         Args:
             result_objects: List of objects returned from the operation
             models_in_chain: List of model classes in the MTI inheritance chain
         """
-        # Split objects by operation type
+        # Split objects based on metadata set by the executor
         created_objects = []
         updated_objects = []
-        
+
+        if not result_objects:
+            return
+
         for obj in result_objects:
-            was_created = getattr(obj, '_bulk_hooks_was_created', True)
-            if was_created:
-                created_objects.append(obj)
+            # Check if metadata was set
+            if hasattr(obj, "_bulk_hooks_was_created"):
+                was_created = getattr(obj, "_bulk_hooks_was_created", True)
+                if was_created:
+                    created_objects.append(obj)
+                else:
+                    updated_objects.append(obj)
             else:
-                updated_objects.append(obj)
-        
-        logger.info(
-            f"Upsert after hooks: {len(created_objects)} created, "
-            f"{len(updated_objects)} updated"
-        )
-        
+                # Fallback: if no metadata, check timestamps
+                model_cls = obj.__class__
+                if hasattr(model_cls, "created_at") and hasattr(model_cls, "updated_at"):
+                    # Reload from DB to get accurate timestamps
+                    db_obj = model_cls.objects.filter(pk=obj.pk).values("created_at", "updated_at").first()
+                    if db_obj:
+                        created_at = db_obj["created_at"]
+                        updated_at = db_obj["updated_at"]
+                        if created_at and updated_at:
+                            time_diff = abs((updated_at - created_at).total_seconds())
+                            if time_diff <= 1.0:  # Within 1 second = just created
+                                created_objects.append(obj)
+                            else:
+                                updated_objects.append(obj)
+                        else:
+                            # No timestamps, default to created
+                            created_objects.append(obj)
+                    else:
+                        # Object not found, treat as created
+                        created_objects.append(obj)
+                else:
+                    # No timestamp fields, default to created
+                    created_objects.append(obj)
+
+        logger.info(f"Upsert after hooks: {len(created_objects)} created, {len(updated_objects)} updated")
+
         # Dispatch after_create hooks for created objects
         if created_objects:
             from django_bulk_hooks.helpers import build_changeset_for_create
+
             create_changeset = build_changeset_for_create(self.model_cls, created_objects)
-            
+
             for model_cls in models_in_chain:
                 model_changeset = self._build_changeset_for_model(create_changeset, model_cls)
                 self.dispatcher.dispatch(model_changeset, "after_create", bypass_hooks=False)
-        
+
         # Dispatch after_update hooks for updated objects
         if updated_objects:
             # Fetch old records for proper change detection
             old_records_map = self.analyzer.fetch_old_records_map(updated_objects)
-            
+
             from django_bulk_hooks.helpers import build_changeset_for_update
+
             update_changeset = build_changeset_for_update(
                 self.model_cls,
                 updated_objects,
                 update_kwargs={},  # Empty since we don't know specific fields
                 old_records_map=old_records_map,
             )
-            
+
             for model_cls in models_in_chain:
                 model_changeset = self._build_changeset_for_model(update_changeset, model_cls)
                 self.dispatcher.dispatch(model_changeset, "after_update", bypass_hooks=False)
-        
+
         # Clean up temporary metadata
         self._cleanup_upsert_metadata(result_objects)
 
     def _cleanup_upsert_metadata(self, result_objects):
         """
         Clean up temporary metadata added during upsert operations.
-        
+
         Args:
             result_objects: List of objects to clean up
         """
         for obj in result_objects:
-            if hasattr(obj, '_bulk_hooks_was_created'):
-                delattr(obj, '_bulk_hooks_was_created')
-            if hasattr(obj, '_bulk_hooks_upsert_metadata'):
-                delattr(obj, '_bulk_hooks_upsert_metadata')
+            if hasattr(obj, "_bulk_hooks_was_created"):
+                delattr(obj, "_bulk_hooks_was_created")
+            if hasattr(obj, "_bulk_hooks_upsert_metadata"):
+                delattr(obj, "_bulk_hooks_upsert_metadata")

{django_bulk_hooks-0.2.44 → django_bulk_hooks-0.2.46}/django_bulk_hooks/operations/mti_handler.py

@@ -20,7 +20,7 @@ class MTIHandler:
 
     This service detects MTI models and builds execution plans.
     It does NOT execute database operations - that's the BulkExecutor's job.
-    
+
     Responsibilities:
     - Detect MTI models
     - Build inheritance chains
@@ -45,8 +45,9 @@ class MTIHandler:
         Returns:
             bool: True if model has concrete parent models
         """
-        for parent in self.model_cls._meta.all_parents:
-            if parent._meta.concrete_model != self.model_cls._meta.concrete_model:
+        # Check if this model has concrete parent models (not abstract)
+        for parent in self.model_cls._meta.parents.keys():
+            if not parent._meta.abstract and parent._meta.concrete_model != self.model_cls._meta.concrete_model:
                 return True
         return False
 
@@ -73,15 +74,12 @@ class MTIHandler:
         current_model = self.model_cls
 
         while current_model:
-            if not current_model._meta.proxy:
+            if not current_model._meta.proxy and not current_model._meta.abstract:
                 chain.append(current_model)
 
-            # Get concrete parent models
-            parents = [
-                parent
-                for parent in current_model._meta.parents.keys()
-                if not parent._meta.proxy
-            ]
+            # Get concrete parent models (not abstract, not proxy)
+            parents = [parent for parent in current_model._meta.parents.keys() 
+                      if not parent._meta.proxy and not parent._meta.abstract]
 
             current_model = parents[0] if parents else None
 
@@ -127,10 +125,10 @@ class MTIHandler:
     ):
         """
         Build an execution plan for bulk creating MTI model instances.
-        
+
         This method does NOT execute any database operations.
         It returns a plan that the BulkExecutor will execute.
-        
+
         Args:
             objs: List of model instances to create
             batch_size: Number of objects per batch
@@ -139,7 +137,7 @@ class MTIHandler:
             update_fields: Fields to update on conflict
             existing_record_ids: Set of id() for objects that exist in DB (from RecordClassifier)
             existing_pks_map: Dict mapping id(obj) -> pk for existing records (from RecordClassifier)
-            
+
         Returns:
             MTICreatePlan object
         """
@@ -205,9 +203,9 @@ class MTIHandler:
     ):
         """
         Build parent level objects for each level in the inheritance chain.
-        
+
         This is pure in-memory object creation - no DB operations.
-        
+
         Returns:
             List of ParentLevel objects
         """
@@ -255,16 +253,14 @@ class MTIHandler:
                 # Check if this model has a matching constraint
                 if normalized_unique and self._has_matching_constraint(model_class, normalized_unique):
                     # Filter update fields
-                    filtered_updates = [
-                        uf for uf in (update_fields or []) if uf in model_fields_by_name
-                    ]
+                    filtered_updates = [uf for uf in (update_fields or []) if uf in model_fields_by_name]
 
                     # If no fields to update at this level but we need upsert to prevent
                     # unique constraint violations, use one of the unique fields as a dummy
                     # update field (updating it to itself is a safe no-op)
                     if not filtered_updates and normalized_unique:
                         filtered_updates = [normalized_unique[0]]
-                    
+
                     # Only enable upsert if we have fields to update (real or dummy)
                     if filtered_updates:
                         level_update_conflicts = True
@@ -288,10 +284,8 @@ class MTIHandler:
         """Check if model has a unique constraint matching the given fields."""
         try:
             from django.db.models import UniqueConstraint
-            constraint_field_sets = [
-                tuple(c.fields) for c in model_class._meta.constraints
-                if isinstance(c, UniqueConstraint)
-            ]
+
+            constraint_field_sets = [tuple(c.fields) for c in model_class._meta.constraints if isinstance(c, UniqueConstraint)]
         except Exception:
             constraint_field_sets = []
 
@@ -319,12 +313,12 @@ class MTIHandler:
     def _create_parent_instance(self, source_obj, parent_model, current_parent):
         """
         Create a parent instance from source object (in-memory only).
-        
+
         Args:
             source_obj: Original object with data
             parent_model: Parent model class to create instance of
             current_parent: Parent instance from previous level (if any)
-            
+
         Returns:
             Parent model instance (not saved)
         """
@@ -335,8 +329,7 @@ class MTIHandler:
             if hasattr(source_obj, field.name):
                 value = getattr(source_obj, field.name, None)
                 if value is not None:
-                    if (field.is_relation and not field.many_to_many and
-                        not field.one_to_many):
+                    if field.is_relation and not field.many_to_many and not field.one_to_many:
                         # Handle FK fields
                         if hasattr(value, "pk") and value.pk is not None:
                             setattr(parent_obj, field.attname, value.pk)
@@ -348,8 +341,7 @@ class MTIHandler:
         # Link to parent if exists
         if current_parent is not None:
             for field in parent_model._meta.local_fields:
-                if (hasattr(field, "remote_field") and field.remote_field and
-                    field.remote_field.model == current_parent.__class__):
+                if hasattr(field, "remote_field") and field.remote_field and field.remote_field.model == current_parent.__class__:
                     setattr(parent_obj, field.name, current_parent)
                     break
 
@@ -373,13 +365,13 @@ class MTIHandler:
     def _create_child_instance_template(self, source_obj, child_model):
         """
         Create a child instance template (in-memory only, without parent links).
-        
+
         The executor will add parent links after creating parent objects.
-        
+
         Args:
             source_obj: Original object with data
             child_model: Child model class
-            
+
         Returns:
             Child model instance (not saved, no parent links)
         """
@@ -399,8 +391,7 @@ class MTIHandler:
             if hasattr(source_obj, field.name):
                 value = getattr(source_obj, field.name, None)
                 if value is not None:
-                    if (field.is_relation and not field.many_to_many and
-                        not field.one_to_many):
+                    if field.is_relation and not field.many_to_many and not field.one_to_many:
                         if hasattr(value, "pk") and value.pk is not None:
                             setattr(child_obj, field.attname, value.pk)
                         else:
@@ -430,14 +421,14 @@ class MTIHandler:
     def build_update_plan(self, objs, fields, batch_size=None):
         """
         Build an execution plan for bulk updating MTI model instances.
-        
+
         This method does NOT execute any database operations.
-        
+
         Args:
             objs: List of model instances to update
             fields: List of field names to update
             batch_size: Number of objects per batch
-            
+
         Returns:
             MTIUpdatePlan object
         """
@@ -497,11 +488,13 @@ class MTIHandler:
                             break
                     filter_field = parent_link.attname if parent_link else "pk"
 
-                field_groups.append(ModelFieldGroup(
-                    model_class=model,
-                    fields=model_fields,
-                    filter_field=filter_field,
-                ))
+                field_groups.append(
+                    ModelFieldGroup(
+                        model_class=model,
+                        fields=model_fields,
+                        filter_field=filter_field,
+                    )
+                )
 
         return MTIUpdatePlan(
             inheritance_chain=inheritance_chain,

{django_bulk_hooks-0.2.44 → django_bulk_hooks-0.2.46}/django_bulk_hooks/operations/mti_plans.py

@@ -14,7 +14,7 @@ from typing import Any
 class ParentLevel:
     """
     Represents one level in the parent hierarchy for MTI bulk create.
-    
+
     Attributes:
         model_class: The parent model class for this level
         objects: List of parent instances to create
@@ -23,6 +23,7 @@ class ParentLevel:
         unique_fields: Fields for conflict detection (if update_conflicts=True)
         update_fields: Fields to update on conflict (if update_conflicts=True)
     """
+
     model_class: Any
     objects: list[Any]
     original_object_map: dict[int, int] = field(default_factory=dict)
@@ -35,10 +36,10 @@ class ParentLevel:
 class MTICreatePlan:
     """
     Plan for executing bulk_create on an MTI model.
-    
+
     This plan describes WHAT to create, not HOW to create it.
     The executor is responsible for executing this plan.
-    
+
     Attributes:
         inheritance_chain: List of model classes from root to child
         parent_levels: List of ParentLevel objects, one per parent model
@@ -51,6 +52,7 @@ class MTICreatePlan:
         unique_fields: Fields used for conflict detection
         update_fields: Fields to update on conflict
     """
+
     inheritance_chain: list[Any]
     parent_levels: list[ParentLevel]
     child_objects: list[Any]
@@ -67,12 +69,13 @@ class MTICreatePlan:
 class ModelFieldGroup:
     """
     Represents fields to update for one model in the inheritance chain.
-    
+
     Attributes:
         model_class: The model class
         fields: List of field names to update on this model
         filter_field: Field to use for filtering (e.g., 'pk' or parent link attname)
     """
+
     model_class: Any
     fields: list[str]
     filter_field: str = "pk"
@@ -82,15 +85,15 @@ class ModelFieldGroup:
 class MTIUpdatePlan:
     """
     Plan for executing bulk_update on an MTI model.
-    
+
     Attributes:
         inheritance_chain: List of model classes from root to child
         field_groups: List of ModelFieldGroup objects
         objects: Objects to update
         batch_size: Batch size for operations
     """
+
     inheritance_chain: list[Any]
     field_groups: list[ModelFieldGroup]
     objects: list[Any]
     batch_size: int = None
-

{django_bulk_hooks-0.2.44 → django_bulk_hooks-0.2.46}/django_bulk_hooks/operations/record_classifier.py

@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 class RecordClassifier:
     """
     Service for classifying and fetching records via database queries.
-    
+
     This is the SINGLE point of truth for record classification queries.
     Keeps database access logic separate from business/planning logic.
     """
@@ -34,14 +34,14 @@ class RecordClassifier:
     def classify_for_upsert(self, objs, unique_fields):
         """
         Classify records as new or existing based on unique_fields.
-        
+
         Queries the database to check which records already exist based on the
         unique_fields constraint.
-        
+
         Args:
             objs: List of model instances
             unique_fields: List of field names that form the unique constraint
-            
+
         Returns:
             Tuple of (existing_record_ids, existing_pks_map)
             - existing_record_ids: Set of id() for objects that exist in DB
@@ -77,9 +77,12 @@ class RecordClassifier:
         for q in queries[1:]:
             combined_query |= q
 
-        existing_records = list(
-            self.model_cls.objects.filter(combined_query).values("pk", *unique_fields),
-        )
+        logger.info(f"Classifying for upsert: model={self.model_cls.__name__}, query={combined_query}, unique_fields={unique_fields}")
+        queryset = self.model_cls.objects.filter(combined_query)
+        logger.info(f"Queryset SQL: {queryset.query}")
+        logger.info(f"All records in table: {self.model_cls.objects.all().count()}")
+        existing_records = list(queryset.values("pk", *unique_fields))
+        logger.info(f"Found {len(existing_records)} existing records: {existing_records}")
 
         # Map existing records back to original objects
         existing_record_ids = set()
@@ -94,8 +97,7 @@ class RecordClassifier:
                     existing_pks_map[obj_id] = record["pk"]
 
         logger.info(
-            f"Classified {len(existing_record_ids)} existing and "
-            f"{len(objs) - len(existing_record_ids)} new records for upsert",
+            f"Classified {len(existing_record_ids)} existing and {len(objs) - len(existing_record_ids)} new records for upsert",
         )
 
         return existing_record_ids, existing_pks_map
@@ -103,12 +105,12 @@ class RecordClassifier:
     def fetch_by_pks(self, pks, select_related=None, prefetch_related=None):
         """
         Fetch records by primary keys with optional relationship loading.
-        
+
         Args:
             pks: List of primary key values
             select_related: Optional list of fields to select_related
             prefetch_related: Optional list of fields to prefetch_related
-            
+
         Returns:
             Dict[pk, instance] for O(1) lookups
         """
@@ -128,10 +130,10 @@ class RecordClassifier:
     def fetch_by_unique_constraint(self, field_values_map):
         """
         Fetch records matching a unique constraint.
-        
+
         Args:
             field_values_map: Dict of {field_name: value} for unique constraint
-            
+
         Returns:
             Model instance if found, None otherwise
         """
@@ -141,18 +143,17 @@ class RecordClassifier:
             return None
         except self.model_cls.MultipleObjectsReturned:
             logger.warning(
-                f"Multiple {self.model_cls.__name__} records found for "
-                f"unique constraint {field_values_map}",
+                f"Multiple {self.model_cls.__name__} records found for unique constraint {field_values_map}",
             )
             return self.model_cls.objects.filter(**field_values_map).first()
 
     def exists_by_pks(self, pks):
         """
         Check if records exist by primary keys without fetching them.
-        
+
         Args:
             pks: List of primary key values
-            
+
         Returns:
             Set of PKs that exist in the database
         """
@@ -168,13 +169,13 @@ class RecordClassifier:
     def count_by_unique_fields(self, objs, unique_fields):
         """
         Count how many objects already exist based on unique fields.
-        
+
         Useful for validation or reporting before upsert operations.
-        
+
         Args:
             objs: List of model instances
             unique_fields: List of field names that form the unique constraint
-            
+
         Returns:
             Tuple of (existing_count, new_count)
         """

{django_bulk_hooks-0.2.44 → django_bulk_hooks-0.2.46}/pyproject.toml

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