django-bulk-hooks 0.2.49__tar.gz → 0.2.51__tar.gz

{django_bulk_hooks-0.2.49 → django_bulk_hooks-0.2.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.49
+Version: 0.2.51
 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.49 → django_bulk_hooks-0.2.51}/django_bulk_hooks/operations/bulk_executor.py

@@ -10,6 +10,8 @@ from django.db import transaction
 from django.db.models import AutoField, ForeignKey, Case, When, Value
 from django.db.models.functions import Cast
 
+from django_bulk_hooks.operations.field_utils import get_field_value_for_db
+
 logger = logging.getLogger(__name__)
 
 
@@ -243,9 +245,11 @@ class BulkExecutor:
                 # 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)
+                        # Use attname for ForeignKey fields to avoid triggering database queries
+                        field_attr = field.attname if isinstance(field, ForeignKey) else field.name
+                        upserted_value = getattr(upserted_parent, field_attr, None)
                         if upserted_value is not None:
-                            setattr(parent_obj, field.name, upserted_value)
+                            setattr(parent_obj, field_attr, upserted_value)
 
                     parent_obj._state.adding = False
                     parent_obj._state.db = self.queryset.db
@@ -291,14 +295,36 @@ class BulkExecutor:
             # 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)
+            
+            # Check which CHILD records actually exist in the child table
+            # This is separate from checking parent existence
+            if plan.update_conflicts:
+                # Query the CHILD table to see which child records exist
+                parent_pks = []
+                for child_obj in plan.child_objects:
+                    child_pk = getattr(child_obj, plan.child_model._meta.pk.attname, None)
+                    if child_pk:
+                        parent_pks.append(child_pk)
+                
+                existing_child_pks = set()
+                if parent_pks:
+                    existing_child_pks = set(
+                        base_qs.filter(pk__in=parent_pks).values_list('pk', flat=True)
+                    )
+                
+                # Split based on whether child record exists
+                for child_obj in plan.child_objects:
+                    child_pk = getattr(child_obj, plan.child_model._meta.pk.attname, None)
+                    if child_pk and child_pk in existing_child_pks:
+                        # Child record exists - update it
+                        objs_with_pk.append(child_obj)
+                    else:
+                        # Child record doesn't exist - insert it
+                        objs_without_pk.append(child_obj)
+            else:
+                # Not an upsert - all are new records
+                objs_without_pk = plan.child_objects
+                objs_with_pk = []
 
             # For objects with PK (existing records in upsert), use bulk_update
             if objs_with_pk and plan.update_fields:
@@ -451,8 +477,8 @@ class BulkExecutor:
                         if obj_pk is None:
                             continue
 
-                        # Get the field value - handle ForeignKey fields specially
-                        value = getattr(obj, field.attname, None) if is_fk else getattr(obj, field_name)
+                        # Get the field value using centralized field extraction
+                        value = get_field_value_for_db(obj, field_name, obj.__class__)
 
                         # Handle NULL values specially for ForeignKey fields
                         if is_fk and value is None:

django_bulk_hooks-0.2.51/django_bulk_hooks/operations/field_utils.py

@@ -0,0 +1,94 @@
+"""
+Utilities for field value extraction and normalization.
+
+Single source of truth for converting model instance field values
+to their database representation. This eliminates duplicate FK handling
+logic scattered across multiple components.
+"""
+
+import logging
+
+from django.db.models import ForeignKey
+
+logger = logging.getLogger(__name__)
+
+
+def get_field_value_for_db(obj, field_name, model_cls=None):
+    """
+    Get a field value from an object in its database-ready form.
+
+    For regular fields: returns the field value as-is
+    For FK fields: returns the PK (integer) instead of the related object
+
+    This ensures consistent handling across all operations (upsert classification,
+    bulk create, bulk update, etc.)
+
+    Args:
+        obj: Model instance
+        field_name: Name of the field to extract
+        model_cls: Model class (optional, will infer from obj if not provided)
+
+    Returns:
+        Database-ready value (FK as integer, regular fields as-is)
+    """
+    if model_cls is None:
+        model_cls = obj.__class__
+
+    try:
+        field = model_cls._meta.get_field(field_name)
+    except Exception:  # noqa: BLE001
+        # Field doesn't exist - just get attribute
+        return getattr(obj, field_name, None)
+
+    # Check if it's a ForeignKey
+    if isinstance(field, ForeignKey):
+        # For FK fields, always use attname (e.g., 'business_id' not 'business')
+        # This gets the raw FK ID value from the database field
+        return getattr(obj, field.attname, None)
+
+    # Regular field - get normally
+    return getattr(obj, field_name, None)
+
+
+def get_field_values_for_db(obj, field_names, model_cls=None):
+    """
+    Get multiple field values from an object in database-ready form.
+
+    Args:
+        obj: Model instance
+        field_names: List of field names
+        model_cls: Model class (optional)
+
+    Returns:
+        Dict of {field_name: db_value}
+    """
+    if model_cls is None:
+        model_cls = obj.__class__
+
+    return {
+        field_name: get_field_value_for_db(obj, field_name, model_cls)
+        for field_name in field_names
+    }
+
+
+def normalize_field_name_to_db(field_name, model_cls):
+    """
+    Normalize a field name to its database column name.
+
+    For FK fields referenced by relationship name, returns the attname (e.g., 'business' -> 'business_id')
+    For regular fields, returns as-is.
+
+    Args:
+        field_name: Field name (can be 'business' or 'business_id')
+        model_cls: Model class
+
+    Returns:
+        Database column name
+    """
+    try:
+        field = model_cls._meta.get_field(field_name)
+        if isinstance(field, ForeignKey):
+            return field.attname  # Returns 'business_id' for 'business' field
+        return field_name
+    except Exception:  # noqa: BLE001
+        return field_name

{django_bulk_hooks-0.2.49 → django_bulk_hooks-0.2.51}/django_bulk_hooks/operations/mti_handler.py

@@ -11,6 +11,8 @@ import logging
 
 from django.db.models import AutoField
 
+from django_bulk_hooks.operations.field_utils import get_field_value_for_db
+
 logger = logging.getLogger(__name__)
 
 
@@ -354,19 +356,13 @@ class MTIHandler:
         """
         parent_obj = parent_model()
 
-        # Copy field values from source
+        # Copy field values from source using centralized field extraction
         for field in parent_model._meta.local_fields:
             if hasattr(source_obj, field.name):
-                value = getattr(source_obj, field.name, None)
+                # Use centralized field value extraction for consistent FK handling
+                value = get_field_value_for_db(source_obj, field.name, source_obj.__class__)
                 if value is not None:
-                    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)
-                        else:
-                            setattr(parent_obj, field.attname, value)
-                    else:
-                        setattr(parent_obj, field.name, value)
+                    setattr(parent_obj, field.attname, value)
 
         # Link to parent if exists
         if current_parent is not None:
@@ -419,15 +415,10 @@ class MTIHandler:
                     continue
 
             if hasattr(source_obj, field.name):
-                value = getattr(source_obj, field.name, None)
+                # Use centralized field value extraction for consistent FK handling
+                value = get_field_value_for_db(source_obj, field.name, source_obj.__class__)
                 if value is not None:
-                    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:
-                            setattr(child_obj, field.attname, value)
-                    else:
-                        setattr(child_obj, field.name, value)
+                    setattr(child_obj, field.attname, value)
 
         # Copy object state
         if hasattr(source_obj, "_state") and hasattr(child_obj, "_state"):

{django_bulk_hooks-0.2.49 → django_bulk_hooks-0.2.51}/django_bulk_hooks/operations/record_classifier.py

@@ -11,6 +11,8 @@ import logging
 
 from django.db.models import Q
 
+from django_bulk_hooks.operations.field_utils import get_field_value_for_db
+
 logger = logging.getLogger(__name__)
 
 
@@ -61,17 +63,22 @@ class RecordClassifier:
         for obj in objs:
             # Build lookup dict for this object's unique fields
             lookup = {}
+            normalized_values = []
+            
             for field_name in unique_fields:
-                value = getattr(obj, field_name, None)
+                # Use centralized field value extraction for consistent FK handling
+                value = get_field_value_for_db(obj, field_name, query_model)
                 if value is None:
                     # Can't match on None values
                     break
                 lookup[field_name] = value
+                normalized_values.append(value)
             else:
                 # All unique fields have values, add to query
                 if lookup:
                     queries.append(Q(**lookup))
-                    obj_to_unique_values[id(obj)] = tuple(lookup.values())
+                    # Store normalized values for comparison with database results
+                    obj_to_unique_values[id(obj)] = tuple(normalized_values)
 
         if not queries:
             return set(), {}

{django_bulk_hooks-0.2.49 → django_bulk_hooks-0.2.51}/pyproject.toml

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