django-bulk-hooks 0.2.16__py3-none-any.whl → 0.2.19__py3-none-any.whl

django_bulk_hooks/operations/coordinator.py

@@ -6,15 +6,14 @@ a clean, simple API for the QuerySet to use.
 """
 
 import logging
+
+from django.core.exceptions import FieldDoesNotExist
 from django.db import transaction
 from django.db.models import QuerySet
-from django.core.exceptions import FieldDoesNotExist
 
-from django_bulk_hooks.helpers import (
-    build_changeset_for_create,
-    build_changeset_for_update,
-    build_changeset_for_delete,
-)
+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
 
 logger = logging.getLogger(__name__)
 
@@ -196,7 +195,8 @@ class BulkOperationCoordinator:
         old_records_map = self.analyzer.fetch_old_records_map(objs)
 
         # Build changeset
-        from django_bulk_hooks.changeset import ChangeSet, RecordChange
+        from django_bulk_hooks.changeset import ChangeSet
+        from django_bulk_hooks.changeset import RecordChange
 
         changes = [
             RecordChange(
@@ -222,7 +222,7 @@ 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.
@@ -265,7 +265,7 @@ class BulkOperationCoordinator:
         or use bulk_update() directly (which has true before semantics).
         """
         from django_bulk_hooks.context import get_bypass_hooks
-        
+
         # Fast path: no hooks at all
         if bypass_hooks or get_bypass_hooks():
             return QuerySet.update(self.queryset, **update_kwargs)
@@ -277,7 +277,7 @@ 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.
@@ -297,22 +297,22 @@ class BulkOperationCoordinator:
         old_instances = list(self.queryset)
         if not old_instances:
             return 0
-            
+
         old_records_map = {inst.pk: inst for inst in old_instances}
-        
+
         # Step 2: Execute native Django update
         # Use stored reference to parent class method - clean and simple
         update_count = QuerySet.update(self.queryset, **update_kwargs)
-        
+
         if update_count == 0:
             return 0
-        
+
         # Step 3: Fetch new state (after database update)
         # This captures any Subquery/F() computed values
         # Use primary keys to fetch updated instances since queryset filters may no longer match
         pks = [inst.pk for inst in old_instances]
         new_instances = list(self.model_cls.objects.filter(pk__in=pks))
-        
+
         # Step 4: Build changeset
         changeset = build_changeset_for_update(
             self.model_cls,
@@ -320,54 +320,54 @@ class BulkOperationCoordinator:
             update_kwargs,
             old_records_map=old_records_map,
         )
-        
+
         # Mark as queryset update for potential hook inspection
-        changeset.operation_meta['is_queryset_update'] = True
-        changeset.operation_meta['allows_modifications'] = True
-        
+        changeset.operation_meta["is_queryset_update"] = True
+        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())
-        
+
         # 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
+                    model_changeset,
+                    "validate_update",
+                    bypass_hooks=False,
                 )
-        
+
         # Step 7: Run BEFORE_UPDATE hooks with modification tracking
         modified_fields = self._run_before_update_hooks_with_tracking(
-            new_instances, 
-            models_in_chain, 
-            changeset
+            new_instances,
+            models_in_chain,
+            changeset,
         )
-        
+
         # Step 8: Auto-persist BEFORE_UPDATE modifications
         if modified_fields:
             self._persist_hook_modifications(new_instances, modified_fields)
-        
+
         # Step 9: Take snapshot before AFTER_UPDATE hooks
         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
+                model_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)
         if after_modified_fields:
             self._persist_hook_modifications(new_instances, after_modified_fields)
-        
+
         return update_count
 
     def _run_before_update_hooks_with_tracking(self, instances, models_in_chain, changeset):
@@ -383,16 +383,16 @@ class BulkOperationCoordinator:
         """
         # Snapshot current state
         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
+                model_changeset,
+                "before_update",
+                bypass_hooks=False,
             )
-        
+
         # Detect modifications
         return self._detect_modifications(instances, pre_hook_state)
 
@@ -407,26 +407,26 @@ class BulkOperationCoordinator:
             Dict mapping pk -> {field_name: value}
         """
         snapshot = {}
-        
+
         for instance in instances:
             if instance.pk is None:
                 continue
-                
+
             field_values = {}
             for field in self.model_cls._meta.get_fields():
                 # Skip relations that aren't concrete fields
                 if field.many_to_many or field.one_to_many:
                     continue
-                    
+
                 field_name = field.name
                 try:
                     field_values[field_name] = getattr(instance, field_name)
                 except (AttributeError, FieldDoesNotExist):
                     # Field not accessible (e.g., deferred field)
                     field_values[field_name] = None
-                    
+
             snapshot[instance.pk] = field_values
-            
+
         return snapshot
 
     def _detect_modifications(self, instances, pre_hook_state):
@@ -441,23 +441,23 @@ class BulkOperationCoordinator:
             Set of field names that were modified
         """
         modified_fields = set()
-        
+
         for instance in instances:
             if instance.pk not in pre_hook_state:
                 continue
-                
+
             old_values = pre_hook_state[instance.pk]
-            
+
             for field_name, old_value in old_values.items():
                 try:
                     current_value = getattr(instance, field_name)
                 except (AttributeError, FieldDoesNotExist):
                     current_value = None
-                
+
                 # Compare values
                 if current_value != old_value:
                     modified_fields.add(field_name)
-        
+
         return modified_fields
 
     def _persist_hook_modifications(self, instances, modified_fields):
@@ -472,10 +472,10 @@ class BulkOperationCoordinator:
         """
         logger.info(
             f"Hooks modified {len(modified_fields)} field(s): "
-            f"{', '.join(sorted(modified_fields))}"
+            f"{', '.join(sorted(modified_fields))}",
         )
         logger.info("Auto-persisting modifications via bulk_update")
-        
+
         # Use Django's bulk_update directly (not our hook version)
         # Create a fresh QuerySet to avoid recursion
         fresh_qs = QuerySet(model=self.model_cls, using=self.queryset.db)
@@ -567,7 +567,7 @@ class BulkOperationCoordinator:
             ChangeSet for the target model
         """
         from django_bulk_hooks.changeset import ChangeSet
-        
+
         # Create new changeset with target model but same record changes
         return ChangeSet(
             model_cls=target_model_cls,
@@ -577,12 +577,12 @@ class BulkOperationCoordinator:
         )
 
     def _execute_with_mti_hooks(
-        self, 
-        changeset, 
-        operation, 
-        event_prefix, 
-        bypass_hooks=False, 
-        bypass_validation=False
+        self,
+        changeset,
+        operation,
+        event_prefix,
+        bypass_hooks=False,
+        bypass_validation=False,
     ):
         """
         Execute operation with hooks for entire MTI inheritance chain.
@@ -658,7 +658,7 @@ class BulkOperationCoordinator:
                 if (field.is_relation and
                     not field.many_to_many and
                     not field.one_to_many and
-                    hasattr(field, 'attname') 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
@@ -667,4 +667,4 @@ class BulkOperationCoordinator:
                 # If field lookup fails, skip it
                 continue
 
-        return fk_relationships
+        return fk_relationships

django_bulk_hooks/operations/mti_handler.py

@@ -8,6 +8,7 @@ It returns plans (data structures) that the BulkExecutor executes.
 """
 
 import logging
+
 from django.db.models import AutoField
 
 logger = logging.getLogger(__name__)
@@ -142,30 +143,30 @@ class MTIHandler:
         Returns:
             MTICreatePlan object
         """
-        from django_bulk_hooks.operations.mti_plans import MTICreatePlan, ParentLevel
-        
+        from django_bulk_hooks.operations.mti_plans import MTICreatePlan
+
         if not objs:
             return None
-        
+
         inheritance_chain = self.get_inheritance_chain()
         if len(inheritance_chain) <= 1:
             raise ValueError("build_create_plan called on non-MTI model")
-        
+
         batch_size = batch_size or len(objs)
-        
+
         # Use provided classification (no more DB query here!)
         if existing_record_ids is None:
             existing_record_ids = set()
         if existing_pks_map is None:
             existing_pks_map = {}
-        
+
         # Set PKs on existing objects so they can be updated
         if existing_pks_map:
             for obj in objs:
                 if id(obj) in existing_pks_map:
-                    setattr(obj, 'pk', existing_pks_map[id(obj)])
-                    setattr(obj, 'id', existing_pks_map[id(obj)])
-        
+                    obj.pk = existing_pks_map[id(obj)]
+                    obj.id = existing_pks_map[id(obj)]
+
         # Build parent levels
         parent_levels = self._build_parent_levels(
             objs,
@@ -174,13 +175,13 @@ class MTIHandler:
             unique_fields=unique_fields,
             update_fields=update_fields,
         )
-        
+
         # Build child object templates (without parent links - executor adds them)
         child_objects = []
         for obj in objs:
             child_obj = self._create_child_instance_template(obj, inheritance_chain[-1])
             child_objects.append(child_obj)
-        
+
         return MTICreatePlan(
             inheritance_chain=inheritance_chain,
             parent_levels=parent_levels,
@@ -211,38 +212,38 @@ class MTIHandler:
             List of ParentLevel objects
         """
         from django_bulk_hooks.operations.mti_plans import ParentLevel
-        
+
         parent_levels = []
         parent_instances_map = {}  # Maps obj id() -> {model_class: parent_instance}
-        
+
         for level_idx, model_class in enumerate(inheritance_chain[:-1]):
             parent_objs_for_level = []
-            
+
             for obj in objs:
                 # Get current parent from previous level
                 current_parent = None
                 if level_idx > 0:
                     prev_parents = parent_instances_map.get(id(obj), {})
                     current_parent = prev_parents.get(inheritance_chain[level_idx - 1])
-                
+
                 # Create parent instance
                 parent_obj = self._create_parent_instance(obj, model_class, current_parent)
                 parent_objs_for_level.append(parent_obj)
-                
+
                 # Store in map
                 if id(obj) not in parent_instances_map:
                     parent_instances_map[id(obj)] = {}
                 parent_instances_map[id(obj)][model_class] = parent_obj
-            
+
             # Determine upsert parameters for this level
             level_update_conflicts = False
             level_unique_fields = []
             level_update_fields = []
-            
+
             if update_conflicts and unique_fields:
                 # Filter unique_fields and update_fields to only those in this model
                 model_fields_by_name = {f.name: f for f in model_class._meta.local_fields}
-                
+
                 # Normalize unique fields
                 normalized_unique = []
                 for uf in unique_fields or []:
@@ -250,19 +251,19 @@ class MTIHandler:
                         normalized_unique.append(uf)
                     elif uf.endswith("_id") and uf[:-3] in model_fields_by_name:
                         normalized_unique.append(uf[:-3])
-                
+
                 # 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
                     ]
-                    
+
                     if filtered_updates:
                         level_update_conflicts = True
                         level_unique_fields = normalized_unique
                         level_update_fields = filtered_updates
-            
+
             # Create parent level
             parent_level = ParentLevel(
                 model_class=model_class,
@@ -273,7 +274,7 @@ class MTIHandler:
                 update_fields=level_update_fields,
             )
             parent_levels.append(parent_level)
-        
+
         return parent_levels
 
     def _has_matching_constraint(self, model_class, normalized_unique):
@@ -281,28 +282,28 @@ class MTIHandler:
         try:
             from django.db.models import UniqueConstraint
             constraint_field_sets = [
-                tuple(c.fields) for c in model_class._meta.constraints 
+                tuple(c.fields) for c in model_class._meta.constraints
                 if isinstance(c, UniqueConstraint)
             ]
         except Exception:
             constraint_field_sets = []
-        
+
         # Check unique_together
         ut = getattr(model_class._meta, "unique_together", ()) or ()
         if isinstance(ut, tuple) and ut and not isinstance(ut[0], (list, tuple)):
             ut = (ut,)
         ut_field_sets = [tuple(group) for group in ut]
-        
+
         # Check individual field uniqueness
         unique_field_sets = []
         for field in model_class._meta.local_fields:
             if field.unique and not field.primary_key:
                 unique_field_sets.append((field.name,))
-        
+
         # Compare as sets
         provided_set = set(normalized_unique)
         all_constraint_sets = constraint_field_sets + ut_field_sets + unique_field_sets
-        
+
         for group in all_constraint_sets:
             if provided_set == set(group):
                 return True
@@ -321,13 +322,13 @@ class MTIHandler:
             Parent model instance (not saved)
         """
         parent_obj = parent_model()
-        
+
         # Copy field values from source
         for field in parent_model._meta.local_fields:
             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 
+                    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:
@@ -336,7 +337,7 @@ class MTIHandler:
                             setattr(parent_obj, field.attname, value)
                     else:
                         setattr(parent_obj, field.name, value)
-        
+
         # Link to parent if exists
         if current_parent is not None:
             for field in parent_model._meta.local_fields:
@@ -344,22 +345,22 @@ class MTIHandler:
                     field.remote_field.model == current_parent.__class__):
                     setattr(parent_obj, field.name, current_parent)
                     break
-        
+
         # Copy object state
-        if hasattr(source_obj, '_state') and hasattr(parent_obj, '_state'):
+        if hasattr(source_obj, "_state") and hasattr(parent_obj, "_state"):
             parent_obj._state.adding = source_obj._state.adding
-            if hasattr(source_obj._state, 'db'):
+            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(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):
+            elif getattr(field, "auto_now", False):
                 field.pre_save(parent_obj, add=True)
-        
+
         return parent_obj
 
     def _create_child_instance_template(self, source_obj, child_model):
@@ -376,22 +377,22 @@ class MTIHandler:
             Child model instance (not saved, no parent links)
         """
         child_obj = child_model()
-        
+
         # Copy field values (excluding AutoField and parent links)
         for field in child_model._meta.local_fields:
             if isinstance(field, AutoField):
                 continue
-            
+
             # Skip parent link fields - executor will set these
-            if field.is_relation and hasattr(field, 'related_model'):
+            if field.is_relation and hasattr(field, "related_model"):
                 # Check if this field is a parent link
                 if child_model._meta.get_ancestor_link(field.related_model) == field:
                     continue
-            
+
             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 
+                    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)
@@ -399,22 +400,22 @@ class MTIHandler:
                             setattr(child_obj, field.attname, value)
                     else:
                         setattr(child_obj, field.name, value)
-        
+
         # Copy object state
-        if hasattr(source_obj, '_state') and hasattr(child_obj, '_state'):
+        if hasattr(source_obj, "_state") and hasattr(child_obj, "_state"):
             child_obj._state.adding = source_obj._state.adding
-            if hasattr(source_obj._state, 'db'):
+            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(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):
+            elif getattr(field, "auto_now", False):
                 field.pre_save(child_obj, add=True)
-        
+
         return child_obj
 
     # ==================== MTI BULK UPDATE PLANNING ====================
@@ -433,48 +434,49 @@ class MTIHandler:
         Returns:
             MTIUpdatePlan object
         """
-        from django_bulk_hooks.operations.mti_plans import MTIUpdatePlan, ModelFieldGroup
-        
+        from django_bulk_hooks.operations.mti_plans import ModelFieldGroup
+        from django_bulk_hooks.operations.mti_plans import MTIUpdatePlan
+
         if not objs:
             return None
-        
+
         inheritance_chain = self.get_inheritance_chain()
         if len(inheritance_chain) <= 1:
             raise ValueError("build_update_plan called on non-MTI model")
-        
+
         batch_size = batch_size or len(objs)
-        
+
         # Handle auto_now fields
         for obj in objs:
             for model in inheritance_chain:
                 for field in model._meta.local_fields:
-                    if getattr(field, 'auto_now', False):
+                    if getattr(field, "auto_now", False):
                         field.pre_save(obj, add=False)
-        
+
         # Add auto_now fields to update list
         auto_now_fields = set()
         for model in inheritance_chain:
             for field in model._meta.local_fields:
-                if getattr(field, 'auto_now', False):
+                if getattr(field, "auto_now", False):
                     auto_now_fields.add(field.name)
-        
+
         all_fields = list(fields) + list(auto_now_fields)
-        
+
         # Group fields by model
         field_groups = []
         for model_idx, model in enumerate(inheritance_chain):
             model_fields = []
-            
+
             for field_name in all_fields:
                 try:
                     field = self.model_cls._meta.get_field(field_name)
                     if field in model._meta.local_fields:
                         # Skip auto_now_add fields for updates
-                        if not getattr(field, 'auto_now_add', False):
+                        if not getattr(field, "auto_now_add", False):
                             model_fields.append(field_name)
                 except Exception:
                     continue
-            
+
             if model_fields:
                 # Determine filter field
                 if model_idx == 0:
@@ -487,13 +489,13 @@ class MTIHandler:
                             parent_link = model._meta.parents[parent_model]
                             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,
                 ))
-        
+
         return MTIUpdatePlan(
             inheritance_chain=inheritance_chain,
             field_groups=field_groups,