django-bulk-hooks 0.2.50__tar.gz → 0.2.52__tar.gz

{django_bulk_hooks-0.2.50 → django_bulk_hooks-0.2.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.50
+Version: 0.2.52
 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.50 → django_bulk_hooks-0.2.52}/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__)
 
 
@@ -475,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.52/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.50 → django_bulk_hooks-0.2.52}/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__)
 
 
@@ -119,26 +121,29 @@ class MTIHandler:
         - If parent exists but child doesn't: creating child for existing parent → AFTER_UPDATE
         - If neither exists: creating both parent and child → AFTER_CREATE
 
-        Therefore, we return the root parent model to check if the parent record exists,
-        regardless of where the unique fields are defined.
+        Therefore, we find the model that contains all the unique fields, regardless
+        of whether it's the parent or child model.
 
         Args:
             unique_fields: List of field names forming the unique constraint
 
         Returns:
-            Model class to query for existing records (root parent for MTI)
+            Model class to query for existing records (model containing unique fields)
         """
         if not unique_fields:
             return self.model_cls
 
         inheritance_chain = self.get_inheritance_chain()
 
-        # For MTI models with multiple levels, return the root parent model
-        # This ensures we check if the parent exists, which determines create vs update hooks
+        # For MTI models, find the model in the chain that contains ALL unique fields
         if len(inheritance_chain) > 1:
-            return inheritance_chain[0]  # Root parent model
+            # Walk through inheritance chain from child to parent
+            for model in reversed(inheritance_chain):  # Start with child, end with root parent
+                model_field_names = {f.name for f in model._meta.local_fields}
+                if all(field in model_field_names for field in unique_fields):
+                    return model
 
-        # For non-MTI models (shouldn't happen, but safe fallback)
+        # For non-MTI models or as fallback
         return self.model_cls
 
     # ==================== MTI BULK CREATE PLANNING ====================
@@ -354,19 +359,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 +418,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.50 → django_bulk_hooks-0.2.52}/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.50 → django_bulk_hooks-0.2.52}/pyproject.toml

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