django-bulk-hooks 0.1.190__py3-none-any.whl → 0.1.192__py3-none-any.whl

django_bulk_hooks/manager.py

@@ -3,55 +3,24 @@ from django.db import models
 from django_bulk_hooks.queryset import HookQuerySet, HookQuerySetMixin
 
 
-def inject_bulk_hook_behavior(queryset):
-    """
-    Dynamically inject bulk hook behavior into any queryset.
-    This follows the industry-standard pattern for cooperative queryset extensions.
-    
-    Args:
-        queryset: Any Django QuerySet instance
-        
-    Returns:
-        A new queryset instance with bulk hook functionality added
-    """
-    if isinstance(queryset, HookQuerySetMixin):
-        # Already has hook functionality, return as-is
-        return queryset
-    
-    # Create a new class that inherits from both HookQuerySetMixin and the queryset's class
-    HookedQuerySetClass = type(
-        "HookedQuerySet",
-        (HookQuerySetMixin, queryset.__class__),
-        {
-            '__module__': 'django_bulk_hooks.queryset',
-            '__doc__': f'Dynamically created queryset with bulk hook functionality for {queryset.__class__.__name__}'
-        }
-    )
-    
-    # Create a new instance with the same parameters
-    new_queryset = HookedQuerySetClass(
-        model=queryset.model,
-        query=queryset.query,
-        using=queryset._db,
-        hints=queryset._hints
-    )
-    
-    # Copy any additional attributes that might be important
-    for attr, value in queryset.__dict__.items():
-        if not hasattr(new_queryset, attr):
-            setattr(new_queryset, attr, value)
-    
-    return new_queryset
-
-
 class BulkHookManager(models.Manager):
     def get_queryset(self):
         # Use super().get_queryset() to let Django and MRO build the queryset
         # This ensures cooperation with other managers
         base_queryset = super().get_queryset()
         
-        # Inject our bulk hook behavior into the queryset
-        return inject_bulk_hook_behavior(base_queryset)
+        # If the base queryset already has hook functionality, return it as-is
+        if isinstance(base_queryset, HookQuerySetMixin):
+            return base_queryset
+        
+        # Otherwise, create a new HookQuerySet with the same parameters
+        # This is much simpler and avoids dynamic class creation issues
+        return HookQuerySet(
+            model=base_queryset.model,
+            query=base_queryset.query,
+            using=base_queryset._db,
+            hints=base_queryset._hints
+        )
 
     def bulk_create(
         self,

django_bulk_hooks/queryset.py

@@ -183,17 +183,9 @@ class HookQuerySetMixin:
         """
         Bulk update objects in the database with MTI support.
         """
-        print(f"\n=== BULK UPDATE DEBUG ===")
-        print(f"Model: {self.model.__name__}")
-        print(f"Number of objects: {len(objs)}")
-        print(f"Fields: {fields}")
-        print(f"Bypass hooks: {bypass_hooks}")
-        print(f"Bypass validation: {bypass_validation}")
-        
         model_cls = self.model
 
         if not objs:
-            print("No objects to update")
             return []
 
         if any(not isinstance(obj, model_cls) for obj in objs):
@@ -207,11 +199,6 @@ class HookQuerySetMixin:
             if parent._meta.concrete_model is not model_cls._meta.concrete_model:
                 is_mti = True
                 break
-        
-        print(f"Is MTI: {is_mti}")
-        print(f"Model concrete model: {model_cls._meta.concrete_model.__name__}")
-        for parent in model_cls._meta.all_parents:
-            print(f"  Parent {parent.__name__}: concrete_model = {parent._meta.concrete_model.__name__}")
 
         if not bypass_hooks:
             # Load originals for hook comparison
@@ -238,14 +225,11 @@ class HookQuerySetMixin:
                 fields_set = set(fields)
                 fields_set.update(modified_fields)
                 fields = list(fields_set)
-                print(f"Modified fields detected: {modified_fields}")
 
         # Handle MTI models differently
         if is_mti:
-            print("Using MTI bulk update logic")
             result = self._mti_bulk_update(objs, fields, **kwargs)
         else:
-            print("Using standard Django bulk_update")
             # For single-table models, use Django's built-in bulk_update
             django_kwargs = {
                 k: v
@@ -257,7 +241,6 @@ class HookQuerySetMixin:
         if not bypass_hooks:
             engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
 
-        print(f"Bulk update result: {result}")
         return result
 
     def _detect_modified_fields(self, new_instances, original_instances):
@@ -302,29 +285,20 @@ class HookQuerySetMixin:
         Get the complete inheritance chain from root parent to current model.
         Returns list of model classes in order: [RootParent, Parent, Child]
         """
-        print(f"\n=== GET INHERITANCE CHAIN DEBUG ===")
-        print(f"Current model: {self.model.__name__}")
-        
         chain = []
         current_model = self.model
         while current_model:
-            print(f"Processing model: {current_model.__name__}")
             if not current_model._meta.proxy:
                 chain.append(current_model)
-                print(f"  Added to chain: {current_model.__name__}")
-            else:
-                print(f"  Skipped proxy model: {current_model.__name__}")
             
             parents = [
                 parent
                 for parent in current_model._meta.parents.keys()
                 if not parent._meta.proxy
             ]
-            print(f"  Parents: {[p.__name__ for p in parents]}")
             current_model = parents[0] if parents else None
         
         chain.reverse()
-        print(f"Final inheritance chain: {[m.__name__ for m in chain]}")
         return chain
 
     def _mti_bulk_create(self, objs, inheritance_chain=None, **kwargs):
@@ -567,14 +541,8 @@ class HookQuerySetMixin:
         Custom bulk update implementation for MTI models.
         Updates each table in the inheritance chain efficiently using Django's batch_size.
         """
-        print(f"\n=== MTI BULK UPDATE DEBUG ===")
-        print(f"Model: {self.model.__name__}")
-        print(f"Number of objects: {len(objs)}")
-        print(f"Fields to update: {fields}")
-        
         model_cls = self.model
         inheritance_chain = self._get_inheritance_chain()
-        print(f"Inheritance chain: {[m.__name__ for m in inheritance_chain]}")
 
         # Remove custom hook kwargs before passing to Django internals
         django_kwargs = {
@@ -599,28 +567,20 @@ class HookQuerySetMixin:
                     if model not in field_groups:
                         field_groups[model] = []
                     field_groups[model].append(field_name)
-                    print(f"Field '{field_name}' belongs to model '{model.__name__}'")
                     break
-        
-        print(f"Field groups: {field_groups}")
 
         # Process in batches
         batch_size = django_kwargs.get("batch_size") or len(objs)
         total_updated = 0
         
-        print(f"Processing in batches of size: {batch_size}")
-        
         with transaction.atomic(using=self.db, savepoint=False):
             for i in range(0, len(objs), batch_size):
                 batch = objs[i : i + batch_size]
-                print(f"\n--- Processing batch {i//batch_size + 1} ({len(batch)} objects) ---")
                 batch_result = self._process_mti_bulk_update_batch(
                     batch, field_groups, inheritance_chain, **django_kwargs
                 )
                 total_updated += batch_result
-                print(f"Batch {i//batch_size + 1} updated {batch_result} rows")
 
-        print(f"\n=== TOTAL UPDATED: {total_updated} ===")
         return total_updated
 
     def _process_mti_bulk_update_batch(self, batch, field_groups, inheritance_chain, **kwargs):
@@ -630,9 +590,6 @@ class HookQuerySetMixin:
         """
         total_updated = 0
         
-        print(f"Processing batch with {len(batch)} objects")
-        print(f"Field groups: {field_groups}")
-        
         # For MTI, we need to handle parent links correctly
         # The root model (first in chain) has its own PK
         # Child models use the parent link to reference the root PK
@@ -649,31 +606,21 @@ class HookQuerySetMixin:
             
             if pk_value is not None:
                 root_pks.append(pk_value)
-                print(f"Found PK {pk_value} for object {obj}")
             else:
-                print(f"WARNING: Object {obj} has no primary key (pk={getattr(obj, 'pk', None)}, id={getattr(obj, 'id', None)})")
                 continue
         
-        print(f"Root PKs to update: {root_pks}")
-        
         if not root_pks:
-            print("No valid primary keys found, skipping update")
             return 0
         
         # Update each table in the inheritance chain
         for model, model_fields in field_groups.items():
-            print(f"\n--- Updating model: {model.__name__} ---")
-            print(f"Fields to update: {model_fields}")
-            
             if not model_fields:
-                print("No fields to update, skipping")
                 continue
 
             if model == inheritance_chain[0]:
                 # Root model - use primary keys directly
                 pks = root_pks
                 filter_field = 'pk'
-                print(f"Root model - using PKs: {pks}")
             else:
                 # Child model - use parent link field
                 parent_link = None
@@ -683,27 +630,19 @@ class HookQuerySetMixin:
                         break
                 
                 if parent_link is None:
-                    print(f"No parent link found for {model.__name__}, skipping")
                     continue
                 
-                print(f"Parent link field: {parent_link.name} ({parent_link.attname})")
-                
                 # For child models, the parent link values should be the same as root PKs
                 pks = root_pks
                 filter_field = parent_link.attname
-                print(f"Child model - using parent link values: {pks}")
             
             if pks:
                 base_qs = model._base_manager.using(self.db)
-                print(f"Filter field: {filter_field}")
-                print(f"PKs to filter by: {pks}")
                 
                 # Check if records exist
                 existing_count = base_qs.filter(**{f"{filter_field}__in": pks}).count()
-                print(f"Existing records with these PKs: {existing_count}")
                 
                 if existing_count == 0:
-                    print("WARNING: No existing records found with these PKs!")
                     continue
                 
                 # Build CASE statements for each field to perform a single bulk update
@@ -712,7 +651,6 @@ class HookQuerySetMixin:
                     field = model._meta.get_field(field_name)
                     when_statements = []
                     
-                    print(f"Building CASE statement for field: {field_name}")
                     for pk, obj in zip(pks, batch):
                         # Check both pk and id attributes for the object
                         obj_pk = getattr(obj, 'pk', None)
@@ -722,26 +660,18 @@ class HookQuerySetMixin:
                         if obj_pk is None:
                             continue
                         value = getattr(obj, field_name)
-                        print(f"  PK {pk}: {field_name} = {value}")
                         when_statements.append(When(**{filter_field: pk}, then=Value(value, output_field=field)))
                     
                     case_statements[field_name] = Case(*when_statements, output_field=field)
                 
-                print(f"Case statements built: {list(case_statements.keys())}")
-                
                 # Execute a single bulk update for all objects in this model
                 try:
                     updated_count = base_qs.filter(**{f"{filter_field}__in": pks}).update(**case_statements)
-                    print(f"UPDATE QUERY EXECUTED - Updated {updated_count} rows")
                     total_updated += updated_count
                 except Exception as e:
-                    print(f"ERROR during update: {e}")
                     import traceback
                     traceback.print_exc()
-            else:
-                print("No PKs found, skipping update")
 
-        print(f"Batch total updated: {total_updated}")
         return total_updated
 
 

{django_bulk_hooks-0.1.190.dist-info → django_bulk_hooks-0.1.192.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.190
+Version: 0.1.192
 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.190.dist-info → django_bulk_hooks-0.1.192.dist-info}/RECORD

@@ -6,12 +6,12 @@ django_bulk_hooks/decorators.py,sha256=WD7Jn7QAvY8F4wOsYlIpjoM9-FdHXSKB7hH9ot-lk
 django_bulk_hooks/engine.py,sha256=nA5PU9msk_Ju5Gf_sTd7GqPscuTxEW5itCDAoSScYGI,1645
 django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
 django_bulk_hooks/handler.py,sha256=xZt8iNdYF-ACz-MnKMY0co6scWINU5V5wC1lyDn844k,4854
-django_bulk_hooks/manager.py,sha256=YvkwOix_740hxahCtDg1sK3eTHTAZnUSyF1T09VNBaY,4671
+django_bulk_hooks/manager.py,sha256=nfWiwU5-yAoxdnQsUMohxtyCpkV0MBv6X3wmipr9eQY,3697
 django_bulk_hooks/models.py,sha256=7fnx5xd4HWXfLVlFhhiRzR92JRWFEuxgk6aSWLEsyJg,3996
 django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
-django_bulk_hooks/queryset.py,sha256=eaeSmYW3VrJjhom_wXKzndmEkrKm-xaG0qflYhKSgIA,31663
+django_bulk_hooks/queryset.py,sha256=G8tzhFM8tirPXLJi0KwGWuybugboJoix21z7j_lPqJ4,27908
 django_bulk_hooks/registry.py,sha256=-mQBizJ06nz_tajZBinViKx_uP2Tbc1tIpTEMv7lwKA,705
-django_bulk_hooks-0.1.190.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.190.dist-info/METADATA,sha256=SskcUNxKkMSOb_OG2APxuDQf-pocG6dgPlXIBCg7PeY,7418
-django_bulk_hooks-0.1.190.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.1.190.dist-info/RECORD,,
+django_bulk_hooks-0.1.192.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.192.dist-info/METADATA,sha256=4QTA06jIRiiURXxuvwnQVLf6qTURJD48Zadn9PufPAk,7418
+django_bulk_hooks-0.1.192.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.1.192.dist-info/RECORD,,