django-bulk-hooks 0.1.258__tar.gz → 0.1.260__tar.gz

{django_bulk_hooks-0.1.258 → django_bulk_hooks-0.1.260}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.258
+Version: 0.1.260
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.1.258 → django_bulk_hooks-0.1.260}/django_bulk_hooks/queryset.py

@@ -89,7 +89,7 @@ class HookQuerySetMixin:
         try:
             from django.db.models import Subquery
 
-            logger.debug(f"Successfully imported Subquery from django.db.models")
+            logger.debug("Successfully imported Subquery from django.db.models")
         except ImportError as e:
             logger.error(f"Failed to import Subquery: {e}")
             raise
@@ -367,7 +367,7 @@ class HookQuerySetMixin:
 
                 if has_nested_subquery:
                     logger.debug(
-                        f"Expression contains Subquery, ensuring proper output_field"
+                        "Expression contains Subquery, ensuring proper output_field"
                     )
                     # Try to resolve the expression to ensure it's properly formatted
                     try:
@@ -531,6 +531,10 @@ class HookQuerySetMixin:
                 # Check which records already exist in the database based on unique fields
                 existing_records = []
                 new_records = []
+
+                # Store the records for AFTER hooks to avoid duplicate queries
+                ctx.upsert_existing_records = existing_records
+                ctx.upsert_new_records = new_records
                 
                 # Build a filter to check which records already exist
                 unique_values = []
@@ -541,9 +545,9 @@ class HookQuerySetMixin:
                             unique_value[field_name] = getattr(obj, field_name)
                     if unique_value:
                         unique_values.append(unique_value)
-                
+
                 if unique_values:
-                    # Query the database to see which records already exist
+                    # Query the database to see which records already exist - SINGLE BULK QUERY
                     from django.db.models import Q
                     existing_filters = Q()
                     for unique_value in unique_values:
@@ -551,25 +555,25 @@ class HookQuerySetMixin:
                         for field_name, value in unique_value.items():
                             filter_kwargs[field_name] = value
                         existing_filters |= Q(**filter_kwargs)
-                    
-                    existing_pks = set(
-                        model_cls.objects.filter(existing_filters).values_list('pk', flat=True)
-                    )
-                    
+
+                    # Get all existing records in one query and create a lookup set
+                    existing_records_lookup = set()
+                    for existing_record in model_cls.objects.filter(existing_filters).values_list(*unique_fields):
+                        # Convert tuple to a hashable key for lookup
+                        existing_records_lookup.add(existing_record)
+
                     # Separate records based on whether they already exist
                     for obj in objs:
                         obj_unique_value = {}
                         for field_name in unique_fields:
                             if hasattr(obj, field_name):
                                 obj_unique_value[field_name] = getattr(obj, field_name)
-                        
-                        # Check if this record already exists
+
+                        # Check if this record already exists using our bulk lookup
                         if obj_unique_value:
-                            existing_q = Q()
-                            for field_name, value in obj_unique_value.items():
-                                existing_q &= Q(**{field_name: value})
-                            
-                            if model_cls.objects.filter(existing_q).exists():
+                            # Convert object values to tuple for comparison with existing records
+                            obj_unique_tuple = tuple(obj_unique_value[field_name] for field_name in unique_fields)
+                            if obj_unique_tuple in existing_records_lookup:
                                 existing_records.append(obj)
                             else:
                                 new_records.append(obj)
@@ -579,7 +583,7 @@ class HookQuerySetMixin:
                 else:
                     # If no unique fields, treat all as new
                     new_records = objs
-                
+
                 # Handle auto_now fields intelligently for upsert operations
                 # Only set auto_now fields on records that will actually be created
                 for obj in new_records:
@@ -619,29 +623,30 @@ class HookQuerySetMixin:
                             key = tuple(getattr(db_record, field) for field in unique_fields)
                             existing_db_map[key] = db_record
                         
-                        # Preserve auto_now field values for existing records
+                        # For existing records, populate all fields from database and set auto_now fields
                         for obj in existing_records:
                             key = tuple(getattr(obj, field) for field in unique_fields)
                             if key in existing_db_map:
                                 db_record = existing_db_map[key]
+                                # Copy all fields from the database record to ensure completeness
+                                populated_fields = []
+                                for field in model_cls._meta.local_fields:
+                                    if field.name != 'id':  # Don't overwrite the ID
+                                        db_value = getattr(db_record, field.name)
+                                        if db_value is not None:  # Only set non-None values
+                                            setattr(obj, field.name, db_value)
+                                            populated_fields.append(field.name)
+                                print(f"DEBUG: Populated {len(populated_fields)} fields for existing record: {populated_fields}")
+                                logger.debug(f"Populated {len(populated_fields)} fields for existing record: {populated_fields}")
+                                
+                                # Now set auto_now fields using Django's pre_save method
                                 for field in model_cls._meta.local_fields:
                                     if hasattr(field, "auto_now") and field.auto_now:
-                                        # Preserve the original updated_at timestamp
-                                        setattr(obj, field.name, getattr(db_record, field.name))
+                                        field.pre_save(obj, add=False)  # add=False for updates
+                                        print(f"DEBUG: Set {field.name} using pre_save for existing record {obj.pk}")
+                                        logger.debug(f"Set {field.name} using pre_save for existing record {obj.pk}")
                 
-                # CRITICAL: For existing records, we need to set updated_at to current time
-                # since they are being updated, not just preserved
-                if existing_records:
-                    from django.utils import timezone
-                    current_time = timezone.now()
-                    print(f"DEBUG: Setting updated_at to current time for {len(existing_records)} existing records")
-                    logger.debug(f"Setting updated_at to current time for {len(existing_records)} existing records")
-                    for obj in existing_records:
-                        for field in model_cls._meta.local_fields:
-                            if hasattr(field, "auto_now") and field.auto_now:
-                                setattr(obj, field.name, current_time)
-                                print(f"DEBUG: Set {field.name} to {current_time} for existing record {obj.pk}")
-                                logger.debug(f"Set {field.name} to {current_time} for existing record {obj.pk}")
+                # Remove duplicate code since we're now handling this above
                 
                 # CRITICAL: Exclude auto_now fields from update_fields for existing records
                 # This prevents Django from including them in the ON CONFLICT DO UPDATE clause
@@ -752,59 +757,66 @@ class HookQuerySetMixin:
                     delattr(ctx, 'auto_now_fields_excluded')
                     logger.debug(f"Restored update_fields: {update_fields}")
                 
-                # For upsert operations, we need to determine which records were actually created vs updated
-                # Use the same logic as before to separate records
-                existing_records = []
-                new_records = []
-                
-                # Build a filter to check which records already exist
-                unique_values = []
-                for obj in objs:
-                    unique_value = {}
-                    for field_name in unique_fields:
-                        if hasattr(obj, field_name):
-                            unique_value[field_name] = getattr(obj, field_name)
-                    if unique_value:
-                        unique_values.append(unique_value)
-                
-                if unique_values:
-                    # Query the database to see which records already exist
-                    from django.db.models import Q
-                    existing_filters = Q()
-                    for unique_value in unique_values:
-                        filter_kwargs = {}
-                        for field_name, value in unique_value.items():
-                            filter_kwargs[field_name] = value
-                        existing_filters |= Q(**filter_kwargs)
-                    
-                    existing_pks = set(
-                        model_cls.objects.filter(existing_filters).values_list('pk', flat=True)
-                    )
-                    
-                    # Separate records based on whether they already exist
+                # For upsert operations, reuse the existing/new records determination from BEFORE hooks
+                # This avoids duplicate queries and improves performance
+                if hasattr(ctx, 'upsert_existing_records') and hasattr(ctx, 'upsert_new_records'):
+                    existing_records = ctx.upsert_existing_records
+                    new_records = ctx.upsert_new_records
+                    logger.debug(f"Reusing upsert record classification from BEFORE hooks: {len(existing_records)} existing, {len(new_records)} new")
+                else:
+                    # Fallback: determine records that actually exist after bulk operation
+                    logger.warning("Upsert record classification not found in context, performing fallback query")
+                    existing_records = []
+                    new_records = []
+
+                    # Build a filter to check which records now exist
+                    unique_values = []
                     for obj in objs:
-                        obj_unique_value = {}
+                        unique_value = {}
                         for field_name in unique_fields:
                             if hasattr(obj, field_name):
-                                obj_unique_value[field_name] = getattr(obj, field_name)
-                        
-                        # Check if this record already exists
-                        if obj_unique_value:
-                            existing_q = Q()
-                            for field_name, value in obj_unique_value.items():
-                                existing_q &= Q(**{field_name: value})
-                            
-                            if model_cls.objects.filter(existing_q).exists():
-                                existing_records.append(obj)
+                                unique_value[field_name] = getattr(obj, field_name)
+                        if unique_value:
+                            unique_values.append(unique_value)
+
+                    if unique_values:
+                        # Query the database to see which records exist after bulk operation
+                        from django.db.models import Q
+                        existing_filters = Q()
+                        for unique_value in unique_values:
+                            filter_kwargs = {}
+                            for field_name, value in unique_value.items():
+                                filter_kwargs[field_name] = value
+                            existing_filters |= Q(**filter_kwargs)
+
+                        # Get all existing records in one query and create a lookup set
+                        existing_records_lookup = set()
+                        for existing_record in model_cls.objects.filter(existing_filters).values_list(*unique_fields):
+                            # Convert tuple to a hashable key for lookup
+                            existing_records_lookup.add(existing_record)
+
+                        # Separate records based on whether they now exist
+                        for obj in objs:
+                            obj_unique_value = {}
+                            for field_name in unique_fields:
+                                if hasattr(obj, field_name):
+                                    obj_unique_value[field_name] = getattr(obj, field_name)
+
+                            # Check if this record exists using our bulk lookup
+                            if obj_unique_value:
+                                # Convert object values to tuple for comparison with existing records
+                                obj_unique_tuple = tuple(obj_unique_value[field_name] for field_name in unique_fields)
+                                if obj_unique_tuple in existing_records_lookup:
+                                    existing_records.append(obj)
+                                else:
+                                    new_records.append(obj)
                             else:
+                                # If we can't determine uniqueness, treat as new
                                 new_records.append(obj)
-                        else:
-                            # If we can't determine uniqueness, treat as new
-                            new_records.append(obj)
-                else:
-                    # If no unique fields, treat all as new
-                    new_records = objs
-                
+                    else:
+                        # If no unique fields, treat all as new
+                        new_records = objs
+
                 # Run appropriate AFTER hooks based on what actually happened
                 if new_records:
                     engine.run(model_cls, AFTER_CREATE, new_records, ctx=ctx)
@@ -860,7 +872,8 @@ class HookQuerySetMixin:
         fields_set = set(fields)
         pk_fields = model_cls._meta.pk_fields
         auto_now_fields = []
-        logger.debug(f"Checking for auto_now fields in {model_cls.__name__}")
+        custom_update_fields = []  # Fields that need pre_save() called on update
+        logger.debug(f"Checking for auto_now and custom update fields in {model_cls.__name__}")
         for field in model_cls._meta.local_concrete_fields:
             # Only add auto_now fields (like updated_at) that aren't already in the fields list
             # Don't include auto_now_add fields (like created_at) as they should only be set on creation
@@ -879,6 +892,13 @@ class HookQuerySetMixin:
                     print(f"DEBUG: Auto_now field {field.name} already in fields list or is PK")
             elif hasattr(field, "auto_now_add") and field.auto_now_add:
                 logger.debug(f"Found auto_now_add field: {field.name} (skipping)")
+            # Check for custom fields that might need pre_save() on update (like CurrentUserField)
+            elif hasattr(field, 'pre_save'):
+                # Only call pre_save on fields that aren't already being updated
+                if field.name not in fields_set and field.name not in pk_fields:
+                    custom_update_fields.append(field)
+                    logger.debug(f"Found custom field with pre_save: {field.name}")
+                    print(f"DEBUG: Found custom field with pre_save: {field.name}")
         
         logger.debug(f"Auto_now fields detected: {auto_now_fields}")
         print(f"DEBUG: Auto_now fields detected: {auto_now_fields}")
@@ -895,6 +915,28 @@ class HookQuerySetMixin:
                     setattr(obj, field_name, current_time)
                     print(f"DEBUG: Set {field_name} to {current_time} for object {obj.pk}")
 
+        # Call pre_save() on custom fields that need update handling
+        if custom_update_fields:
+            logger.debug(f"Calling pre_save() on custom update fields: {[f.name for f in custom_update_fields]}")
+            print(f"DEBUG: Calling pre_save() on custom update fields: {[f.name for f in custom_update_fields]}")
+            for obj in objs:
+                for field in custom_update_fields:
+                    try:
+                        # Call pre_save with add=False to indicate this is an update
+                        new_value = field.pre_save(obj, add=False)
+                        # Only update the field if pre_save returned a new value
+                        if new_value is not None:
+                            setattr(obj, field.name, new_value)
+                            # Add this field to the update fields if it's not already there
+                            if field.name not in fields_set:
+                                fields_set.add(field.name)
+                                fields.append(field.name)
+                            logger.debug(f"Custom field {field.name} updated via pre_save() for object {obj.pk}")
+                            print(f"DEBUG: Custom field {field.name} updated via pre_save() for object {obj.pk}")
+                    except Exception as e:
+                        logger.warning(f"Failed to call pre_save() on custom field {field.name}: {e}")
+                        print(f"DEBUG: Failed to call pre_save() on custom field {field.name}: {e}")
+
         # Handle MTI models differently
         if is_mti:
             result = self._mti_bulk_update(objs, fields, **kwargs)
@@ -1270,13 +1312,24 @@ class HookQuerySetMixin:
                 "Inheritance chain too deep - possible infinite recursion detected"
             )
 
-        # Handle auto_now fields by calling pre_save on objects
-        # Check all models in the inheritance chain for auto_now fields
+        # Handle auto_now fields and custom fields by calling pre_save on objects
+        # Check all models in the inheritance chain for auto_now and custom fields
+        custom_update_fields = []
         for obj in objs:
             for model in inheritance_chain:
                 for field in model._meta.local_fields:
                     if hasattr(field, "auto_now") and field.auto_now:
                         field.pre_save(obj, add=False)
+                    # Check for custom fields that might need pre_save() on update (like CurrentUserField)
+                    elif hasattr(field, 'pre_save') and field.name not in fields:
+                        try:
+                            new_value = field.pre_save(obj, add=False)
+                            if new_value is not None:
+                                setattr(obj, field.name, new_value)
+                                custom_update_fields.append(field.name)
+                                logger.debug(f"Custom field {field.name} updated via pre_save() for MTI object {obj.pk}")
+                        except Exception as e:
+                            logger.warning(f"Failed to call pre_save() on custom field {field.name} in MTI: {e}")
 
         # Add auto_now fields to the fields list so they get updated in the database
         auto_now_fields = set()
@@ -1285,8 +1338,8 @@ class HookQuerySetMixin:
                 if hasattr(field, "auto_now") and field.auto_now:
                     auto_now_fields.add(field.name)
 
-        # Combine original fields with auto_now fields
-        all_fields = list(fields) + list(auto_now_fields)
+        # Add custom fields that were updated to the fields list
+        all_fields = list(fields) + list(auto_now_fields) + custom_update_fields
 
         # Group fields by model in the inheritance chain
         field_groups = {}

{django_bulk_hooks-0.1.258 → django_bulk_hooks-0.1.260}/pyproject.toml

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