django-bulk-hooks 0.1.251__tar.gz → 0.1.253__tar.gz

{django_bulk_hooks-0.1.251 → django_bulk_hooks-0.1.253}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.251
+Version: 0.1.253
 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.251 → django_bulk_hooks-0.1.253}/django_bulk_hooks/queryset.py

@@ -520,9 +520,133 @@ class HookQuerySetMixin:
         # Fire hooks before DB ops
         if not bypass_hooks:
             ctx = HookContext(model_cls, bypass_hooks=False)  # Pass bypass_hooks
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
-            engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
+            
+            if update_conflicts and unique_fields:
+                # For upsert operations, we need to determine which records will be created vs updated
+                # Check which records already exist in the database based on unique fields
+                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 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
+                        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)
+                            else:
+                                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
+                
+                # 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:
+                    for field in model_cls._meta.local_fields:
+                        if hasattr(field, "auto_now") and field.auto_now:
+                            field.pre_save(obj, add=True)
+                        elif hasattr(field, "auto_now_add") and field.auto_now_add:
+                            if getattr(obj, field.name) is None:
+                                field.pre_save(obj, add=True)
+                
+                # For existing records, preserve their original auto_now values
+                # We'll need to fetch them from the database to preserve the timestamps
+                if existing_records:
+                    # Get the unique field values for existing records
+                    existing_unique_values = []
+                    for obj in existing_records:
+                        unique_value = {}
+                        for field_name in unique_fields:
+                            if hasattr(obj, field_name):
+                                unique_value[field_name] = getattr(obj, field_name)
+                        if unique_value:
+                            existing_unique_values.append(unique_value)
+                    
+                    if existing_unique_values:
+                        # Build filter to fetch existing records
+                        existing_filters = Q()
+                        for unique_value in existing_unique_values:
+                            filter_kwargs = {}
+                            for field_name, value in unique_value.items():
+                                filter_kwargs[field_name] = value
+                            existing_filters |= Q(**filter_kwargs)
+                        
+                        # Fetch existing records to preserve their auto_now values
+                        existing_db_records = model_cls.objects.filter(existing_filters)
+                        existing_db_map = {}
+                        for db_record in existing_db_records:
+                            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 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]
+                                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))
+                
+                # Run validation hooks on all records
+                if not bypass_validation:
+                    engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
+                
+                # Run appropriate BEFORE hooks based on what will happen
+                if new_records:
+                    engine.run(model_cls, BEFORE_CREATE, new_records, ctx=ctx)
+                if existing_records:
+                    engine.run(model_cls, BEFORE_UPDATE, existing_records, ctx=ctx)
+            else:
+                # For regular create operations, run create hooks before DB ops
+                # Handle auto_now fields normally for new records
+                for obj in objs:
+                    for field in model_cls._meta.local_fields:
+                        if hasattr(field, "auto_now") and field.auto_now:
+                            field.pre_save(obj, add=True)
+                        elif hasattr(field, "auto_now_add") and field.auto_now_add:
+                            if getattr(obj, field.name) is None:
+                                field.pre_save(obj, add=True)
+                
+                if not bypass_validation:
+                    engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
+                engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
         else:
             ctx = HookContext(model_cls, bypass_hooks=True)  # Pass bypass_hooks
             logger.debug("bulk_create bypassed hooks")
@@ -557,9 +681,70 @@ class HookQuerySetMixin:
                 unique_fields=unique_fields,
             )
 
-        # Fire AFTER_CREATE hooks
+        # Fire AFTER hooks
         if not bypass_hooks:
-            engine.run(model_cls, AFTER_CREATE, objs, ctx=ctx)
+            if update_conflicts and unique_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 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
+                        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)
+                            else:
+                                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
+                
+                # Run appropriate AFTER hooks based on what actually happened
+                if new_records:
+                    engine.run(model_cls, AFTER_CREATE, new_records, ctx=ctx)
+                if existing_records:
+                    engine.run(model_cls, AFTER_UPDATE, existing_records, ctx=ctx)
+            else:
+                # For regular create operations, run create hooks after DB ops
+                engine.run(model_cls, AFTER_CREATE, objs, ctx=ctx)
 
         return result
 

{django_bulk_hooks-0.1.251 → django_bulk_hooks-0.1.253}/pyproject.toml

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