django-bulk-hooks 0.1.173__tar.gz → 0.1.176__tar.gz

{django_bulk_hooks-0.1.173 → django_bulk_hooks-0.1.176}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.173
+Version: 0.1.176
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
-Home-page: https://github.com/AugendLimited/django-bulk-hooks
 License: MIT
 Keywords: django,bulk,hooks
 Author: Konrad Beck
@@ -14,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Django (>=4.0)
+Project-URL: Homepage, https://github.com/AugendLimited/django-bulk-hooks
 Project-URL: Repository, https://github.com/AugendLimited/django-bulk-hooks
 Description-Content-Type: text/markdown
 

{django_bulk_hooks-0.1.173 → django_bulk_hooks-0.1.176}/django_bulk_hooks/manager.py

@@ -58,12 +58,12 @@ class BulkHookManager(models.Manager):
         """
         import inspect
 
-        qs = self.get_queryset()
+        queryset = self.get_queryset()
 
         # Check if this is our HookQuerySet or a different QuerySet
         if (
-            hasattr(qs, "bulk_create")
-            and "bypass_hooks" in inspect.signature(qs.bulk_create).parameters
+            hasattr(queryset, "bulk_create")
+            and "bypass_hooks" in inspect.signature(queryset.bulk_create).parameters
         ):
             # Our HookQuerySet - pass all parameters
             kwargs = {
@@ -73,13 +73,15 @@ class BulkHookManager(models.Manager):
                 "update_fields": update_fields,
                 "unique_fields": unique_fields,
             }
-            return qs.bulk_create(
+            return queryset.bulk_create(
                 objs,
                 bypass_hooks=bypass_hooks,
                 bypass_validation=bypass_validation,
                 **kwargs,
             )
         else:
+            print("Different QuerySet")
+
             # Different QuerySet - only pass standard parameters
             kwargs = {
                 "batch_size": batch_size,
@@ -88,7 +90,7 @@ class BulkHookManager(models.Manager):
                 "update_fields": update_fields,
                 "unique_fields": unique_fields,
             }
-            return qs.bulk_create(objs, **kwargs)
+            return queryset.bulk_create(objs, **kwargs)
 
     def bulk_delete(
         self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False

{django_bulk_hooks-0.1.173 → django_bulk_hooks-0.1.176}/django_bulk_hooks/queryset.py

@@ -24,8 +24,23 @@ class HookQuerySet(models.QuerySet):
         objs = list(self)
         if not objs:
             return 0
-        # Call the base QuerySet implementation to avoid recursion
-        return super().bulk_delete(objs)
+        
+        model_cls = self.model
+        ctx = HookContext(model_cls)
+        
+        # Run validation hooks first
+        engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
+        
+        # Then run business logic hooks
+        engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
+        
+        # Use Django's standard delete() method
+        result = super().delete()
+        
+        # Run AFTER_DELETE hooks
+        engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
+        
+        return result
 
     @transaction.atomic
     def update(self, **kwargs):
@@ -38,7 +53,9 @@ class HookQuerySet(models.QuerySet):
 
         # Load originals for hook comparison and ensure they match the order of instances
         # Use the base manager to avoid recursion
-        original_map = {obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)}
+        original_map = {
+            obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)
+        }
         originals = [original_map.get(obj.pk) for obj in instances]
 
         # Apply field updates to instances
@@ -92,6 +109,14 @@ class HookQuerySet(models.QuerySet):
         # trickier so it's not done yet.
         if batch_size is not None and batch_size <= 0:
             raise ValueError("Batch size must be a positive integer.")
+        
+        if not objs:
+            return objs
+        
+        if any(not isinstance(obj, model_cls) for obj in objs):
+            raise TypeError(
+                f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
+            )
 
         # Check for MTI - if we detect multi-table inheritance, we need special handling
         # This follows Django's approach: check that the parents share the same concrete model
@@ -104,55 +129,35 @@ class HookQuerySet(models.QuerySet):
                 is_mti = True
                 break
 
-        if not objs:
-            return objs
-
-        if any(not isinstance(obj, model_cls) for obj in objs):
-            raise TypeError(
-                f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
-            )
-
         # Fire hooks before DB ops
         if not bypass_hooks:
-            print(f"DEBUG: Firing BEFORE_CREATE hooks for {model_cls}")
-            print(f"DEBUG: Number of objects: {len(objs)}")
-            print(f"DEBUG: Object types: {[type(obj) for obj in objs]}")
-            print(f"DEBUG: QuerySet type: {type(self)}")
-            print(f"DEBUG: Is this HookQuerySet? {isinstance(self, HookQuerySet)}")
             ctx = HookContext(model_cls)
             if not bypass_validation:
-                print(f"DEBUG: Running VALIDATE_CREATE hooks")
                 engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
-            print(f"DEBUG: Running BEFORE_CREATE hooks")
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
-        else:
-            print(f"DEBUG: Skipping hooks due to bypass_hooks=True for {model_cls}")
 
         # For MTI models, we need to handle them specially
         if is_mti:
             # Use our MTI-specific logic
             # Filter out custom parameters that Django's bulk_create doesn't accept
             mti_kwargs = {
-                'batch_size': batch_size,
-                'ignore_conflicts': ignore_conflicts,
-                'update_conflicts': update_conflicts,
-                'update_fields': update_fields,
-                'unique_fields': unique_fields,
+                "batch_size": batch_size,
+                "ignore_conflicts": ignore_conflicts,
+                "update_conflicts": update_conflicts,
+                "update_fields": update_fields,
+                "unique_fields": unique_fields,
             }
             # Remove custom hook kwargs if present in self.bulk_create signature
             result = self._mti_bulk_create(
                 objs,
-                **{k: v for k, v in mti_kwargs.items() if k not in ['bypass_hooks', 'bypass_validation']}
+                mti_kwargs,
             )
         else:
             # For single-table models, use Django's built-in bulk_create
             # but we need to call it on the base manager to avoid recursion
             # Filter out custom parameters that Django's bulk_create doesn't accept
 
-            # Use Django's original QuerySet to avoid recursive calls
-            from django.db.models import QuerySet
-            original_qs = QuerySet(model_cls, using=self.db)
-            result = original_qs.bulk_create(
+            result = super().bulk_create(
                 objs,
                 batch_size=batch_size,
                 ignore_conflicts=ignore_conflicts,
@@ -163,37 +168,19 @@ class HookQuerySet(models.QuerySet):
 
         # Fire AFTER_CREATE hooks
         if not bypass_hooks:
-            print(f"DEBUG: Firing AFTER_CREATE hooks for {model_cls}")
-            print(f"DEBUG: Number of objects: {len(objs)}")
-            print(f"DEBUG: QuerySet type: {type(self)}")
-            print(f"DEBUG: Is this HookQuerySet? {isinstance(self, HookQuerySet)}")
             engine.run(model_cls, AFTER_CREATE, objs, ctx=ctx)
-        else:
-            print(f"DEBUG: Skipping AFTER_CREATE hooks due to bypass_hooks=True for {model_cls}")
 
         return result
 
     @transaction.atomic
-    def bulk_update(self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs):
+    def bulk_update(
+        self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
+    ):
         """
         Bulk update objects in the database.
         """
-        import inspect
-        print(f"DEBUG: QuerySet.bulk_update called with:")
-        print(f"  - self: {type(self)}")
-        print(f"  - objs: {type(objs)}")
-        print(f"  - fields: {fields}")
-        print(f"  - bypass_hooks: {bypass_hooks}")
-        print(f"  - bypass_validation: {bypass_validation}")
-        print(f"  - kwargs: {kwargs}")
-        print(f"DEBUG: Method signature: {inspect.signature(self.bulk_update)}")
-        
         model_cls = self.model
-        print(f"DEBUG: Model class: {model_cls}")
-        print(f"DEBUG: bypass_hooks value: {bypass_hooks}")
-        print(f"DEBUG: QuerySet type: {type(self)}")
-        print(f"DEBUG: Is this HookQuerySet? {isinstance(self, HookQuerySet)}")
-        
+
         if not objs:
             return []
 
@@ -207,7 +194,9 @@ class HookQuerySet(models.QuerySet):
             # Use the base manager to avoid recursion
             original_map = {
                 obj.pk: obj
-                for obj in model_cls._base_manager.filter(pk__in=[obj.pk for obj in objs])
+                for obj in model_cls._base_manager.filter(
+                    pk__in=[obj.pk for obj in objs]
+                )
             }
             originals = [original_map.get(obj.pk) for obj in objs]
 
@@ -219,12 +208,7 @@ class HookQuerySet(models.QuerySet):
 
             # Then run business logic hooks
             if not bypass_hooks:
-                print(f"DEBUG: Firing BEFORE_UPDATE hooks for {model_cls}")
-                print(f"DEBUG: Number of objects: {len(objs)}")
-                print(f"DEBUG: Object types: {[type(obj) for obj in objs]}")
                 engine.run(model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx)
-            else:
-                print(f"DEBUG: Skipping hooks due to bypass_hooks=True for {model_cls}")
 
             # Automatically detect fields that were modified during BEFORE_UPDATE hooks
             modified_fields = self._detect_modified_fields(objs, originals)
@@ -234,55 +218,15 @@ class HookQuerySet(models.QuerySet):
                 fields_set.update(modified_fields)
                 fields = list(fields_set)
 
-        for i in range(0, len(objs), self.CHUNK_SIZE):
-            chunk = objs[i : i + self.CHUNK_SIZE]
-
-            # Call the base implementation to avoid re-triggering this method
-            # Filter out custom parameters that Django's bulk_update doesn't accept
-            django_kwargs = {k: v for k, v in kwargs.items() if k not in ['bypass_hooks', 'bypass_validation']}
-            super().bulk_update(chunk, fields, **django_kwargs)
+        django_kwargs = {
+            k: v
+            for k, v in kwargs.items()
+            if k not in ["bypass_hooks", "bypass_validation"]
+        }
+        super().bulk_update(objs, fields, **django_kwargs)
 
         if not bypass_hooks:
-            print(f"DEBUG: Firing AFTER_UPDATE hooks for {model_cls}")
-            print(f"DEBUG: Number of objects: {len(objs)}")
             engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
-        else:
-            print(f"DEBUG: Skipping AFTER_UPDATE hooks due to bypass_hooks=True for {model_cls}")
-
-        return objs
-
-    @transaction.atomic
-    def bulk_delete(
-        self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False
-    ):
-        if not objs:
-            return []
-
-        model_cls = self.model
-
-        if any(not isinstance(obj, model_cls) for obj in objs):
-            raise TypeError(
-                f"bulk_delete expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
-            )
-
-        ctx = HookContext(model_cls)
-
-        if not bypass_hooks:
-            # Run validation hooks first
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
-
-            # Then run business logic hooks
-            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
-
-        pks = [obj.pk for obj in objs if obj.pk is not None]
-
-        # Call the base QuerySet implementation to avoid recursion
-        # The hooks have already been fired above, so we don't need them again
-        super().bulk_delete(objs, batch_size=batch_size)
-
-        if not bypass_hooks:
-            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
 
         return objs
 
@@ -350,7 +294,11 @@ class HookQuerySet(models.QuerySet):
         Sets auto_now_add/auto_now fields for each model in the chain.
         """
         # Remove custom hook kwargs before passing to Django internals
-        django_kwargs = {k: v for k, v in kwargs.items() if k not in ['bypass_hooks', 'bypass_validation']}
+        django_kwargs = {
+            k: v
+            for k, v in kwargs.items()
+            if k not in ["bypass_hooks", "bypass_validation"]
+        }
         if inheritance_chain is None:
             inheritance_chain = self._get_inheritance_chain()
 
@@ -383,9 +331,9 @@ class HookQuerySet(models.QuerySet):
 
         # Step 1: Do O(n) normal inserts into parent tables to get primary keys back
         # Get bypass_hooks from kwargs
-        bypass_hooks = kwargs.get('bypass_hooks', False)
-        bypass_validation = kwargs.get('bypass_validation', False)
-        
+        bypass_hooks = kwargs.get("bypass_hooks", False)
+        bypass_validation = kwargs.get("bypass_validation", False)
+
         for obj in batch:
             parent_instances = {}
             current_parent = None
@@ -393,32 +341,35 @@ class HookQuerySet(models.QuerySet):
                 parent_obj = self._create_parent_instance(
                     obj, model_class, current_parent
                 )
-                
+
                 # Fire parent hooks if not bypassed
                 if not bypass_hooks:
                     ctx = HookContext(model_class)
                     if not bypass_validation:
                         engine.run(model_class, VALIDATE_CREATE, [parent_obj], ctx=ctx)
                     engine.run(model_class, BEFORE_CREATE, [parent_obj], ctx=ctx)
-                
+
                 # Use Django's base manager to create the object and get PKs back
                 # This bypasses hooks and the MTI exception
                 field_values = {
                     field.name: getattr(parent_obj, field.name)
                     for field in model_class._meta.local_fields
-                    if hasattr(parent_obj, field.name) and getattr(parent_obj, field.name) is not None
+                    if hasattr(parent_obj, field.name)
+                    and getattr(parent_obj, field.name) is not None
                 }
-                created_obj = model_class._base_manager.using(self.db).create(**field_values)
-                
+                created_obj = model_class._base_manager.using(self.db).create(
+                    **field_values
+                )
+
                 # Update the parent_obj with the created object's PK
                 parent_obj.pk = created_obj.pk
                 parent_obj._state.adding = False
                 parent_obj._state.db = self.db
-                
+
                 # Fire AFTER_CREATE hooks for parent
                 if not bypass_hooks:
                     engine.run(model_class, AFTER_CREATE, [parent_obj], ctx=ctx)
-                
+
                 parent_instances[model_class] = parent_obj
                 current_parent = parent_obj
             parent_objects_map[id(obj)] = parent_instances
@@ -436,10 +387,10 @@ class HookQuerySet(models.QuerySet):
         if all_child_objects:
             # Get the base manager's queryset
             base_qs = child_model._base_manager.using(self.db)
-            
+
             # Use Django's exact approach: call _prepare_for_bulk_create then partition
             base_qs._prepare_for_bulk_create(all_child_objects)
-            
+
             # Implement our own partition since itertools.partition might not be available
             objs_without_pk, objs_with_pk = [], []
             for obj in all_child_objects:
@@ -447,44 +398,50 @@ class HookQuerySet(models.QuerySet):
                     objs_with_pk.append(obj)
                 else:
                     objs_without_pk.append(obj)
-            
+
             # Use Django's internal _batched_insert method
             opts = child_model._meta
             # For child models in MTI, we need to include the foreign key to the parent
             # but exclude the primary key since it's inherited
-            
+
             # Include all local fields except generated ones
             # We need to include the foreign key to the parent (business_ptr)
             fields = [f for f in opts.local_fields if not f.generated]
-            
+
             with transaction.atomic(using=self.db, savepoint=False):
-                 if objs_with_pk:
-                     returned_columns = base_qs._batched_insert(
-                         objs_with_pk,
-                         fields,
-                         batch_size=len(objs_with_pk),  # Use actual batch size
-                     )
-                     for obj_with_pk, results in zip(objs_with_pk, returned_columns):
-                         for result, field in zip(results, opts.db_returning_fields):
-                             if field != opts.pk:
-                                 setattr(obj_with_pk, field.attname, result)
-                     for obj_with_pk in objs_with_pk:
-                         obj_with_pk._state.adding = False
-                         obj_with_pk._state.db = self.db
-                 
-                 if objs_without_pk:
-                     # For objects without PK, we still need to exclude primary key fields
-                     fields = [f for f in fields if not isinstance(f, AutoField) and not f.primary_key]
-                     returned_columns = base_qs._batched_insert(
-                         objs_without_pk,
-                         fields,
-                         batch_size=len(objs_without_pk),  # Use actual batch size
-                     )
-                     for obj_without_pk, results in zip(objs_without_pk, returned_columns):
-                         for result, field in zip(results, opts.db_returning_fields):
-                             setattr(obj_without_pk, field.attname, result)
-                         obj_without_pk._state.adding = False
-                         obj_without_pk._state.db = self.db
+                if objs_with_pk:
+                    returned_columns = base_qs._batched_insert(
+                        objs_with_pk,
+                        fields,
+                        batch_size=len(objs_with_pk),  # Use actual batch size
+                    )
+                    for obj_with_pk, results in zip(objs_with_pk, returned_columns):
+                        for result, field in zip(results, opts.db_returning_fields):
+                            if field != opts.pk:
+                                setattr(obj_with_pk, field.attname, result)
+                    for obj_with_pk in objs_with_pk:
+                        obj_with_pk._state.adding = False
+                        obj_with_pk._state.db = self.db
+
+                if objs_without_pk:
+                    # For objects without PK, we still need to exclude primary key fields
+                    fields = [
+                        f
+                        for f in fields
+                        if not isinstance(f, AutoField) and not f.primary_key
+                    ]
+                    returned_columns = base_qs._batched_insert(
+                        objs_without_pk,
+                        fields,
+                        batch_size=len(objs_without_pk),  # Use actual batch size
+                    )
+                    for obj_without_pk, results in zip(
+                        objs_without_pk, returned_columns
+                    ):
+                        for result, field in zip(results, opts.db_returning_fields):
+                            setattr(obj_without_pk, field.attname, result)
+                        obj_without_pk._state.adding = False
+                        obj_without_pk._state.db = self.db
 
         # Step 3: Update original objects with generated PKs and state
         pk_field_name = child_model._meta.pk.name
@@ -537,15 +494,19 @@ class HookQuerySet(models.QuerySet):
                 value = getattr(source_obj, field.name, None)
                 if value is not None:
                     setattr(child_obj, field.name, value)
-        
+
         # Set parent links for MTI
         for parent_model, parent_instance in parent_instances.items():
             parent_link = child_model._meta.get_ancestor_link(parent_model)
             if parent_link:
                 # Set both the foreign key value (the ID) and the object reference
                 # This follows Django's pattern in _set_pk_val
-                setattr(child_obj, parent_link.attname, parent_instance.pk)  # Set the foreign key value
-                setattr(child_obj, parent_link.name, parent_instance)        # Set the object reference
+                setattr(
+                    child_obj, parent_link.attname, parent_instance.pk
+                )  # Set the foreign key value
+                setattr(
+                    child_obj, parent_link.name, parent_instance
+                )  # Set the object reference
 
         # Handle auto_now_add and auto_now fields like Django does
         for field in child_model._meta.local_fields:
@@ -558,4 +519,4 @@ class HookQuerySet(models.QuerySet):
             elif hasattr(field, "auto_now") and field.auto_now:
                 field.pre_save(child_obj, add=True)
 
-        return child_obj
+        return child_obj

{django_bulk_hooks-0.1.173 → django_bulk_hooks-0.1.176}/pyproject.toml

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