django-bulk-hooks 0.2.60__py3-none-any.whl → 0.2.62__py3-none-any.whl

django_bulk_hooks/operations/coordinator.py

@@ -14,6 +14,7 @@ from django.db.models import QuerySet
 from django_bulk_hooks.helpers import build_changeset_for_create
 from django_bulk_hooks.helpers import build_changeset_for_delete
 from django_bulk_hooks.helpers import build_changeset_for_update
+from django_bulk_hooks.helpers import extract_pks
 
 logger = logging.getLogger(__name__)
 
@@ -46,55 +47,104 @@ class BulkOperationCoordinator:
         self._executor = None
         self._dispatcher = None
 
+    def _get_or_create_service(self, service_name, service_class, *args, **kwargs):
+        """
+        Generic lazy service initialization.
+
+        Args:
+            service_name: Name of the service attribute (e.g., 'analyzer')
+            service_class: The class to instantiate
+            *args, **kwargs: Arguments to pass to the service constructor
+
+        Returns:
+            The service instance
+        """
+        attr_name = f"_{service_name}"
+        if getattr(self, attr_name) is None:
+            setattr(self, attr_name, service_class(*args, **kwargs))
+        return getattr(self, attr_name)
+
     @property
     def analyzer(self):
         """Get or create ModelAnalyzer"""
-        if self._analyzer is None:
-            from django_bulk_hooks.operations.analyzer import ModelAnalyzer
+        from django_bulk_hooks.operations.analyzer import ModelAnalyzer
 
-            self._analyzer = ModelAnalyzer(self.model_cls)
-        return self._analyzer
+        return self._get_or_create_service("analyzer", ModelAnalyzer, self.model_cls)
 
     @property
     def mti_handler(self):
         """Get or create MTIHandler"""
-        if self._mti_handler is None:
-            from django_bulk_hooks.operations.mti_handler import MTIHandler
+        from django_bulk_hooks.operations.mti_handler import MTIHandler
 
-            self._mti_handler = MTIHandler(self.model_cls)
-        return self._mti_handler
+        return self._get_or_create_service("mti_handler", MTIHandler, self.model_cls)
 
     @property
     def record_classifier(self):
         """Get or create RecordClassifier"""
-        if self._record_classifier is None:
-            from django_bulk_hooks.operations.record_classifier import RecordClassifier
+        from django_bulk_hooks.operations.record_classifier import RecordClassifier
 
-            self._record_classifier = RecordClassifier(self.model_cls)
-        return self._record_classifier
+        return self._get_or_create_service("record_classifier", RecordClassifier, self.model_cls)
 
     @property
     def executor(self):
         """Get or create BulkExecutor"""
-        if self._executor is None:
-            from django_bulk_hooks.operations.bulk_executor import BulkExecutor
-
-            self._executor = BulkExecutor(
-                queryset=self.queryset,
-                analyzer=self.analyzer,
-                mti_handler=self.mti_handler,
-                record_classifier=self.record_classifier,
-            )
-        return self._executor
+        from django_bulk_hooks.operations.bulk_executor import BulkExecutor
+
+        return self._get_or_create_service(
+            "executor",
+            BulkExecutor,
+            queryset=self.queryset,
+            analyzer=self.analyzer,
+            mti_handler=self.mti_handler,
+            record_classifier=self.record_classifier,
+        )
 
     @property
     def dispatcher(self):
         """Get or create Dispatcher"""
-        if self._dispatcher is None:
-            from django_bulk_hooks.dispatcher import get_dispatcher
+        from django_bulk_hooks.dispatcher import get_dispatcher
+
+        return self._get_or_create_service("dispatcher", get_dispatcher)
+
+    @property
+    def inheritance_chain(self):
+        """Single source of truth for inheritance chain"""
+        return self.mti_handler.get_inheritance_chain()
+
+    def _validate_objects_for_operation(self, objs, operation_type):
+        """
+        Validate objects exist and return appropriate empty result.
+
+        Args:
+            objs: List of objects to validate
+            operation_type: 'create', 'update', 'delete', or 'validate'
+
+        Returns:
+            Appropriate empty result for the operation type, or None if objects exist
+        """
+        if not objs:
+            empty_results = {
+                "create": objs,
+                "update": 0,
+                "delete": (0, {}),
+                "validate": None,
+            }
+            return empty_results[operation_type]
+        return None  # Continue with operation
 
-            self._dispatcher = get_dispatcher()
-        return self._dispatcher
+    def _dispatch_hooks_for_models(self, models_in_chain, changeset, event_suffix, bypass_hooks=False):
+        """
+        Dispatch hooks for all models in inheritance chain.
+
+        Args:
+            models_in_chain: List of model classes in MTI inheritance chain
+            changeset: The changeset to use as base
+            event_suffix: Event name suffix (e.g., 'before_create', 'validate_update')
+            bypass_hooks: Whether to skip hook execution
+        """
+        for model_cls in models_in_chain:
+            model_changeset = self._build_changeset_for_model(changeset, model_cls)
+            self.dispatcher.dispatch(model_changeset, event_suffix, bypass_hooks=bypass_hooks)
 
     # ==================== PUBLIC API ====================
 
@@ -126,8 +176,9 @@ class BulkOperationCoordinator:
         Returns:
             List of created objects
         """
-        if not objs:
-            return objs
+        empty_result = self._validate_objects_for_operation(objs, "create")
+        if empty_result is not None:
+            return empty_result
 
         # Validate
         self.analyzer.validate_for_create(objs)
@@ -141,10 +192,8 @@ class BulkOperationCoordinator:
             if self.mti_handler.is_mti_model():
                 query_model = self.mti_handler.find_model_with_unique_fields(unique_fields)
                 logger.info(f"MTI model detected: querying {query_model.__name__} for unique fields {unique_fields}")
-            
-            existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(
-                objs, unique_fields, query_model=query_model
-            )
+
+            existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(objs, unique_fields, query_model=query_model)
             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}")
@@ -203,8 +252,9 @@ class BulkOperationCoordinator:
         Returns:
             Number of objects updated
         """
-        if not objs:
-            return 0
+        empty_result = self._validate_objects_for_operation(objs, "update")
+        if empty_result is not None:
+            return empty_result
 
         # Validate
         self.analyzer.validate_for_update(objs)
@@ -349,19 +399,11 @@ class BulkOperationCoordinator:
         changeset.operation_meta["allows_modifications"] = True
 
         # Step 5: Get MTI inheritance chain
-        models_in_chain = [self.model_cls]
-        if self.mti_handler.is_mti_model():
-            models_in_chain.extend(self.mti_handler.get_parent_models())
+        models_in_chain = self._get_models_in_chain(self.model_cls)
 
         # Step 6: Run VALIDATE hooks (if not bypassed)
         if not bypass_validation:
-            for model_cls in models_in_chain:
-                model_changeset = self._build_changeset_for_model(changeset, model_cls)
-                self.dispatcher.dispatch(
-                    model_changeset,
-                    "validate_update",
-                    bypass_hooks=False,
-                )
+            self._dispatch_hooks_for_models(models_in_chain, changeset, "validate_update", bypass_hooks=False)
 
         # Step 7: Run BEFORE_UPDATE hooks with modification tracking
         modified_fields = self._run_before_update_hooks_with_tracking(
@@ -378,13 +420,7 @@ class BulkOperationCoordinator:
         pre_after_hook_state = self._snapshot_instance_state(new_instances)
 
         # Step 10: Run AFTER_UPDATE hooks (read-only side effects)
-        for model_cls in models_in_chain:
-            model_changeset = self._build_changeset_for_model(changeset, model_cls)
-            self.dispatcher.dispatch(
-                model_changeset,
-                "after_update",
-                bypass_hooks=False,
-            )
+        self._dispatch_hooks_for_models(models_in_chain, changeset, "after_update", bypass_hooks=False)
 
         # Step 11: Auto-persist AFTER_UPDATE modifications (if any)
         after_modified_fields = self._detect_modifications(new_instances, pre_after_hook_state)
@@ -408,13 +444,7 @@ class BulkOperationCoordinator:
         pre_hook_state = self._snapshot_instance_state(instances)
 
         # Run BEFORE_UPDATE hooks
-        for model_cls in models_in_chain:
-            model_changeset = self._build_changeset_for_model(changeset, model_cls)
-            self.dispatcher.dispatch(
-                model_changeset,
-                "before_update",
-                bypass_hooks=False,
-            )
+        self._dispatch_hooks_for_models(models_in_chain, changeset, "before_update", bypass_hooks=False)
 
         # Detect modifications
         return self._detect_modifications(instances, pre_hook_state)
@@ -517,8 +547,9 @@ class BulkOperationCoordinator:
         """
         # Get objects
         objs = list(self.queryset)
-        if not objs:
-            return 0, {}
+        empty_result = self._validate_objects_for_operation(objs, "delete")
+        if empty_result is not None:
+            return empty_result
 
         # Validate
         self.analyzer.validate_for_delete(objs)
@@ -553,13 +584,20 @@ class BulkOperationCoordinator:
         Returns:
             None
         """
-        if not objs:
+        empty_result = self._validate_objects_for_operation(objs, "validate")
+        if empty_result is not None:
             return
 
         # Auto-detect if is_create not specified
         if is_create is None:
             is_create = objs[0].pk is None
 
+        # Use centralized validation logic (consistent with other operations)
+        if is_create:
+            self.analyzer.validate_for_create(objs)
+        else:
+            self.analyzer.validate_for_update(objs)
+
         # Build changeset based on operation type
         if is_create:
             changeset = build_changeset_for_create(self.model_cls, objs)
@@ -569,8 +607,9 @@ class BulkOperationCoordinator:
             changeset = build_changeset_for_update(self.model_cls, objs, {})
             event = "validate_update"
 
-        # Dispatch validation event only
-        self.dispatcher.dispatch(changeset, event, bypass_hooks=False)
+        # Dispatch validation event for entire inheritance chain
+        models_in_chain = self._get_models_in_chain(self.model_cls)
+        self._dispatch_hooks_for_models(models_in_chain, changeset, event)
 
     # ==================== MTI PARENT HOOK SUPPORT ====================
 
@@ -598,6 +637,21 @@ class BulkOperationCoordinator:
             operation_meta=original_changeset.operation_meta,
         )
 
+    def _get_models_in_chain(self, model_cls):
+        """
+        Get all models in the inheritance chain for hook dispatching.
+
+        DEPRECATED: Use self.inheritance_chain property instead for consistency.
+        This method is kept for backward compatibility.
+
+        Args:
+            model_cls: The model class to start from
+
+        Returns:
+            List of model classes in inheritance order [child, parent1, parent2, ...]
+        """
+        return self.inheritance_chain
+
     def _execute_with_mti_hooks(
         self,
         changeset,
@@ -627,21 +681,14 @@ class BulkOperationCoordinator:
             return operation()
 
         # Get all models in inheritance chain
-        models_in_chain = [changeset.model_cls]
-        if self.mti_handler.is_mti_model():
-            parent_models = self.mti_handler.get_parent_models()
-            models_in_chain.extend(parent_models)
+        models_in_chain = self._get_models_in_chain(changeset.model_cls)
 
         # VALIDATE phase - for all models in chain
         if not bypass_validation:
-            for model_cls in models_in_chain:
-                model_changeset = self._build_changeset_for_model(changeset, model_cls)
-                self.dispatcher.dispatch(model_changeset, f"validate_{event_prefix}", bypass_hooks=False)
+            self._dispatch_hooks_for_models(models_in_chain, changeset, f"validate_{event_prefix}")
 
         # BEFORE phase - for all models in chain
-        for model_cls in models_in_chain:
-            model_changeset = self._build_changeset_for_model(changeset, model_cls)
-            self.dispatcher.dispatch(model_changeset, f"before_{event_prefix}", bypass_hooks=False)
+        self._dispatch_hooks_for_models(models_in_chain, changeset, f"before_{event_prefix}")
 
         # Execute the actual operation
         result = operation()
@@ -660,14 +707,10 @@ class BulkOperationCoordinator:
 
                 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)
+                self._dispatch_hooks_for_models(models_in_chain, changeset, f"after_{event_prefix}")
         else:
             # Non-create operations (update, delete)
-            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)
+            self._dispatch_hooks_for_models(models_in_chain, changeset, f"after_{event_prefix}")
 
         return result
 
@@ -768,7 +811,7 @@ class BulkOperationCoordinator:
             for model_cls, objs in objects_by_model.items():
                 if hasattr(model_cls, "created_at") and hasattr(model_cls, "updated_at"):
                     # Bulk fetch timestamps for all objects of this model
-                    pks = [obj.pk for obj in objs if obj.pk is not None]
+                    pks = extract_pks(objs)
                     if pks:
                         timestamp_map = {
                             record["pk"]: (record["created_at"], record["updated_at"])
@@ -806,9 +849,7 @@ class BulkOperationCoordinator:
 
             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)
+            self._dispatch_hooks_for_models(models_in_chain, create_changeset, "after_create", bypass_hooks=False)
 
         # Dispatch after_update hooks for updated objects
         if updated_objects:
@@ -824,9 +865,7 @@ class BulkOperationCoordinator:
                 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)
+            self._dispatch_hooks_for_models(models_in_chain, update_changeset, "after_update", bypass_hooks=False)
 
         # Clean up temporary metadata
         self._cleanup_upsert_metadata(result_objects)

django_bulk_hooks/operations/field_utils.py

@@ -65,10 +65,7 @@ def get_field_values_for_db(obj, field_names, model_cls=None):
     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
-    }
+    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):
@@ -91,4 +88,139 @@ def normalize_field_name_to_db(field_name, model_cls):
             return field.attname  # Returns 'business_id' for 'business' field
         return field_name
     except Exception:  # noqa: BLE001
-        return field_name
+        return field_name
+
+
+def get_changed_fields(old_obj, new_obj, model_cls, skip_auto_fields=False):
+    """
+    Get field names that have changed between two model instances.
+
+    Uses Django's field.get_prep_value() for proper database-level comparison.
+    This is the canonical implementation used by both RecordChange and ModelAnalyzer.
+
+    Args:
+        old_obj: The old model instance
+        new_obj: The new model instance
+        model_cls: The Django model class
+        skip_auto_fields: Whether to skip auto_created fields (default False)
+
+    Returns:
+        Set of field names that have changed
+    """
+    changed = set()
+
+    for field in model_cls._meta.fields:
+        # Skip primary key fields - they shouldn't change
+        if field.primary_key:
+            continue
+
+        # Optionally skip auto-created fields (for bulk operations)
+        if skip_auto_fields and field.auto_created:
+            continue
+
+        old_val = getattr(old_obj, field.name, None)
+        new_val = getattr(new_obj, field.name, None)
+
+        # Use field's get_prep_value for database-ready comparison
+        # This handles timezone conversions, type coercions, etc.
+        try:
+            old_prep = field.get_prep_value(old_val)
+            new_prep = field.get_prep_value(new_val)
+            if old_prep != new_prep:
+                changed.add(field.name)
+        except (TypeError, ValueError):
+            # Fallback to direct comparison if get_prep_value fails
+            if old_val != new_val:
+                changed.add(field.name)
+
+    return changed
+
+
+def get_auto_fields(model_cls, include_auto_now_add=True):
+    """
+    Get auto fields from a model.
+
+    Args:
+        model_cls: Django model class
+        include_auto_now_add: Whether to include auto_now_add fields
+
+    Returns:
+        List of field names
+    """
+    fields = []
+    for field in model_cls._meta.fields:
+        if getattr(field, "auto_now", False) or (include_auto_now_add and getattr(field, "auto_now_add", False)):
+            fields.append(field.name)
+    return fields
+
+
+def get_auto_now_only_fields(model_cls):
+    """Get only auto_now fields (excluding auto_now_add)."""
+    return get_auto_fields(model_cls, include_auto_now_add=False)
+
+
+def get_fk_fields(model_cls):
+    """Get foreign key field names for a model."""
+    return [field.name for field in model_cls._meta.concrete_fields if field.is_relation and not field.many_to_many]
+
+
+def collect_auto_now_fields_for_inheritance_chain(inheritance_chain):
+    """Collect auto_now fields across an MTI inheritance chain."""
+    all_auto_now = set()
+    for model_cls in inheritance_chain:
+        all_auto_now.update(get_auto_now_only_fields(model_cls))
+    return all_auto_now
+
+
+def handle_auto_now_fields_for_inheritance_chain(models, instances, for_update=True):
+    """
+    Unified auto-now field handling for any inheritance chain.
+
+    This replaces the separate collect/pre_save logic with a single comprehensive
+    method that handles collection, pre-saving, and field inclusion for updates.
+
+    Args:
+        models: List of model classes in inheritance chain
+        instances: List of model instances to process
+        for_update: Whether this is for an update operation (vs create)
+
+    Returns:
+        Set of auto_now field names that should be included in updates
+    """
+    all_auto_now_fields = set()
+
+    for model_cls in models:
+        for field in model_cls._meta.local_fields:
+            # For updates, only include auto_now (not auto_now_add)
+            # For creates, include both
+            if getattr(field, "auto_now", False) or (not for_update and getattr(field, "auto_now_add", False)):
+                all_auto_now_fields.add(field.name)
+
+                # Pre-save the field on instances
+                for instance in instances:
+                    if for_update:
+                        # For updates, only pre-save auto_now fields
+                        field.pre_save(instance, add=False)
+                    else:
+                        # For creates, pre-save both auto_now and auto_now_add
+                        field.pre_save(instance, add=True)
+
+    return all_auto_now_fields
+
+
+def pre_save_auto_now_fields(objects, inheritance_chain):
+    """Pre-save auto_now fields across inheritance chain."""
+    # DEPRECATED: Use handle_auto_now_fields_for_inheritance_chain instead
+    auto_now_fields = collect_auto_now_fields_for_inheritance_chain(inheritance_chain)
+
+    for field_name in auto_now_fields:
+        # Find which model has this field
+        for model_cls in inheritance_chain:
+            try:
+                field = model_cls._meta.get_field(field_name)
+                if getattr(field, "auto_now", False):
+                    for obj in objects:
+                        field.pre_save(obj, add=False)
+                    break
+            except Exception:
+                continue

django_bulk_hooks/operations/mti_handler.py

@@ -217,6 +217,12 @@ class MTIHandler:
             child_obj = self._create_child_instance_template(obj, inheritance_chain[-1])
             child_objects.append(child_obj)
 
+        # Pre-compute child-specific fields for execution efficiency
+        from django_bulk_hooks.helpers import get_fields_for_model, filter_field_names_for_model
+
+        child_unique_fields = get_fields_for_model(inheritance_chain[-1], unique_fields or [])
+        child_update_fields = get_fields_for_model(inheritance_chain[-1], update_fields or [])
+
         return MTICreatePlan(
             inheritance_chain=inheritance_chain,
             parent_levels=parent_levels,
@@ -228,6 +234,8 @@ class MTIHandler:
             update_conflicts=update_conflicts,
             unique_fields=unique_fields or [],
             update_fields=update_fields or [],
+            child_unique_fields=child_unique_fields,
+            child_update_fields=child_update_fields,
         )
 
     def _build_parent_levels(
@@ -366,14 +374,14 @@ class MTIHandler:
     def _get_auto_now_fields_for_model(self, model_class, model_fields_by_name):
         """
         Get auto_now (not auto_now_add) fields for a specific model.
-        
+
         Only includes fields that exist in model_fields_by_name to ensure
         they're valid local fields for this model level.
-        
+
         Args:
             model_class: Model class to get fields for
             model_fields_by_name: Dict of valid field names for this model level
-            
+
         Returns:
             List of auto_now field names (excluding auto_now_add)
         """
@@ -458,14 +466,15 @@ class MTIHandler:
             if hasattr(source_obj._state, "db"):
                 parent_obj._state.db = source_obj._state.db
 
-        # Handle auto_now_add and auto_now fields
-        for field in parent_model._meta.local_fields:
-            if getattr(field, "auto_now_add", False):
-                if getattr(parent_obj, field.name) is None:
-                    field.pre_save(parent_obj, add=True)
-                    setattr(parent_obj, field.attname, field.value_from_object(parent_obj))
-            elif getattr(field, "auto_now", False):
-                field.pre_save(parent_obj, add=True)
+        # Use unified auto-now field handling
+        from django_bulk_hooks.operations.field_utils import handle_auto_now_fields_for_inheritance_chain
+
+        # Handle auto fields for this single parent model
+        handle_auto_now_fields_for_inheritance_chain(
+            [parent_model],
+            [parent_obj],
+            for_update=False,  # MTI create is like insert
+        )
 
         return parent_obj
 
@@ -516,14 +525,15 @@ class MTIHandler:
             if hasattr(source_obj._state, "db"):
                 child_obj._state.db = source_obj._state.db
 
-        # Handle auto_now_add and auto_now fields
-        for field in child_model._meta.local_fields:
-            if getattr(field, "auto_now_add", False):
-                if getattr(child_obj, field.name) is None:
-                    field.pre_save(child_obj, add=True)
-                    setattr(child_obj, field.attname, field.value_from_object(child_obj))
-            elif getattr(field, "auto_now", False):
-                field.pre_save(child_obj, add=True)
+        # Use unified auto-now field handling
+        from django_bulk_hooks.operations.field_utils import handle_auto_now_fields_for_inheritance_chain
+
+        # Handle auto fields for this single child model
+        handle_auto_now_fields_for_inheritance_chain(
+            [child_model],
+            [child_obj],
+            for_update=False,  # MTI create is like insert
+        )
 
         return child_obj