django-bulk-hooks 0.1.250__py3-none-any.whl → 0.1.252__py3-none-any.whl

django_bulk_hooks/__init__.py

@@ -1,4 +1,4 @@
-from django_bulk_hooks.handler import Hook as HookClass
-from django_bulk_hooks.manager import BulkHookManager
-
-__all__ = ["BulkHookManager", "HookClass"]
+from django_bulk_hooks.handler import Hook as HookClass
+from django_bulk_hooks.manager import BulkHookManager
+
+__all__ = ["BulkHookManager", "HookClass"]

django_bulk_hooks/handler.py

@@ -1,188 +1,188 @@
-import logging
-import threading
-from collections import deque
-
-from django.db import transaction
-
-from django_bulk_hooks.registry import get_hooks, register_hook
-
-logger = logging.getLogger(__name__)
-
-
-# Thread-local hook context and hook state
-class HookVars(threading.local):
-    def __init__(self):
-        self.new = None
-        self.old = None
-        self.event = None
-        self.model = None
-        self.depth = 0
-
-
-hook_vars = HookVars()
-
-# Hook queue per thread
-_hook_context = threading.local()
-
-
-def get_hook_queue():
-    if not hasattr(_hook_context, "queue"):
-        _hook_context.queue = deque()
-    return _hook_context.queue
-
-
-class HookContextState:
-    @property
-    def is_before(self):
-        return hook_vars.event.startswith("before_") if hook_vars.event else False
-
-    @property
-    def is_after(self):
-        return hook_vars.event.startswith("after_") if hook_vars.event else False
-
-    @property
-    def is_create(self):
-        return "create" in hook_vars.event if hook_vars.event else False
-
-    @property
-    def is_update(self):
-        return "update" in hook_vars.event if hook_vars.event else False
-
-    @property
-    def new(self):
-        return hook_vars.new
-
-    @property
-    def old(self):
-        return hook_vars.old
-
-    @property
-    def model(self):
-        return hook_vars.model
-
-
-HookContext = HookContextState()
-
-
-class HookMeta(type):
-    _registered = set()
-
-    def __new__(mcs, name, bases, namespace):
-        cls = super().__new__(mcs, name, bases, namespace)
-        for method_name, method in namespace.items():
-            if hasattr(method, "hooks_hooks"):
-                for model_cls, event, condition, priority in method.hooks_hooks:
-                    key = (model_cls, event, cls, method_name)
-                    if key not in HookMeta._registered:
-                        register_hook(
-                            model=model_cls,
-                            event=event,
-                            handler_cls=cls,
-                            method_name=method_name,
-                            condition=condition,
-                            priority=priority,
-                        )
-                        HookMeta._registered.add(key)
-        return cls
-
-
-class Hook(metaclass=HookMeta):
-    @classmethod
-    def handle(
-        cls,
-        event: str,
-        model: type,
-        *,
-        new_records: list = None,
-        old_records: list = None,
-        **kwargs,
-    ) -> None:
-        queue = get_hook_queue()
-        queue.append((cls, event, model, new_records, old_records, kwargs))
-        logger.debug(f"Added item to queue: {event}, depth: {hook_vars.depth}")
-
-        # If we're already processing hooks (depth > 0), don't process the queue
-        # The outermost call will process the entire queue
-        if hook_vars.depth > 0:
-            logger.debug(f"Depth > 0, returning without processing queue")
-            return
-
-        # Process the entire queue
-        logger.debug(f"Processing queue with {len(queue)} items")
-        while queue:
-            item = queue.popleft()
-            if len(item) == 6:
-                cls_, event_, model_, new_, old_, kw_ = item
-                logger.debug(f"Processing queue item: {event_}")
-                # Call _process on the Hook class, not the calling class
-                Hook._process(event_, model_, new_, old_, **kw_)
-            else:
-                logger.warning(f"Invalid queue item format: {item}")
-                continue
-
-    @classmethod
-    def _process(
-        cls,
-        event,
-        model,
-        new_records,
-        old_records,
-        **kwargs,
-    ):
-        hook_vars.depth += 1
-        hook_vars.new = new_records
-        hook_vars.old = old_records
-        hook_vars.event = event
-        hook_vars.model = model
-
-        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
-        logger.debug(f"Found {len(hooks)} hooks for {event}")
-
-        def _execute():
-            logger.debug(f"Executing {len(hooks)} hooks for {event}")
-            new_local = new_records or []
-            old_local = old_records or []
-            if len(old_local) < len(new_local):
-                old_local += [None] * (len(new_local) - len(old_local))
-
-            for handler_cls, method_name, condition, priority in hooks:
-                logger.debug(f"Processing hook {handler_cls.__name__}.{method_name}")
-                if condition is not None:
-                    checks = [
-                        condition.check(n, o) for n, o in zip(new_local, old_local)
-                    ]
-                    if not any(checks):
-                        logger.debug(f"Condition failed for {handler_cls.__name__}.{method_name}")
-                        continue
-
-                handler = handler_cls()
-                method = getattr(handler, method_name)
-                logger.debug(f"Executing {handler_cls.__name__}.{method_name}")
-
-                try:
-                    method(
-                        new_records=new_local,
-                        old_records=old_local,
-                        **kwargs,
-                    )
-                    logger.debug(f"Successfully executed {handler_cls.__name__}.{method_name}")
-                except Exception:
-                    logger.exception(
-                        "Error in hook %s.%s", handler_cls.__name__, method_name
-                    )
-
-        conn = transaction.get_connection()
-        logger.debug(f"Transaction in_atomic_block: {conn.in_atomic_block}, event: {event}")
-        try:
-            if conn.in_atomic_block and event.startswith("after_"):
-                logger.debug(f"Deferring {event} to on_commit")
-                transaction.on_commit(_execute)
-            else:
-                logger.debug(f"Executing {event} immediately")
-                _execute()
-        finally:
-            hook_vars.new = None
-            hook_vars.old = None
-            hook_vars.event = None
-            hook_vars.model = None
-            hook_vars.depth -= 1
+import logging
+import threading
+from collections import deque
+
+from django.db import transaction
+
+from django_bulk_hooks.registry import get_hooks, register_hook
+
+logger = logging.getLogger(__name__)
+
+
+# Thread-local hook context and hook state
+class HookVars(threading.local):
+    def __init__(self):
+        self.new = None
+        self.old = None
+        self.event = None
+        self.model = None
+        self.depth = 0
+
+
+hook_vars = HookVars()
+
+# Hook queue per thread
+_hook_context = threading.local()
+
+
+def get_hook_queue():
+    if not hasattr(_hook_context, "queue"):
+        _hook_context.queue = deque()
+    return _hook_context.queue
+
+
+class HookContextState:
+    @property
+    def is_before(self):
+        return hook_vars.event.startswith("before_") if hook_vars.event else False
+
+    @property
+    def is_after(self):
+        return hook_vars.event.startswith("after_") if hook_vars.event else False
+
+    @property
+    def is_create(self):
+        return "create" in hook_vars.event if hook_vars.event else False
+
+    @property
+    def is_update(self):
+        return "update" in hook_vars.event if hook_vars.event else False
+
+    @property
+    def new(self):
+        return hook_vars.new
+
+    @property
+    def old(self):
+        return hook_vars.old
+
+    @property
+    def model(self):
+        return hook_vars.model
+
+
+HookContext = HookContextState()
+
+
+class HookMeta(type):
+    _registered = set()
+
+    def __new__(mcs, name, bases, namespace):
+        cls = super().__new__(mcs, name, bases, namespace)
+        for method_name, method in namespace.items():
+            if hasattr(method, "hooks_hooks"):
+                for model_cls, event, condition, priority in method.hooks_hooks:
+                    key = (model_cls, event, cls, method_name)
+                    if key not in HookMeta._registered:
+                        register_hook(
+                            model=model_cls,
+                            event=event,
+                            handler_cls=cls,
+                            method_name=method_name,
+                            condition=condition,
+                            priority=priority,
+                        )
+                        HookMeta._registered.add(key)
+        return cls
+
+
+class Hook(metaclass=HookMeta):
+    @classmethod
+    def handle(
+        cls,
+        event: str,
+        model: type,
+        *,
+        new_records: list = None,
+        old_records: list = None,
+        **kwargs,
+    ) -> None:
+        queue = get_hook_queue()
+        queue.append((cls, event, model, new_records, old_records, kwargs))
+        logger.debug(f"Added item to queue: {event}, depth: {hook_vars.depth}")
+
+        # If we're already processing hooks (depth > 0), don't process the queue
+        # The outermost call will process the entire queue
+        if hook_vars.depth > 0:
+            logger.debug(f"Depth > 0, returning without processing queue")
+            return
+
+        # Process the entire queue
+        logger.debug(f"Processing queue with {len(queue)} items")
+        while queue:
+            item = queue.popleft()
+            if len(item) == 6:
+                cls_, event_, model_, new_, old_, kw_ = item
+                logger.debug(f"Processing queue item: {event_}")
+                # Call _process on the Hook class, not the calling class
+                Hook._process(event_, model_, new_, old_, **kw_)
+            else:
+                logger.warning(f"Invalid queue item format: {item}")
+                continue
+
+    @classmethod
+    def _process(
+        cls,
+        event,
+        model,
+        new_records,
+        old_records,
+        **kwargs,
+    ):
+        hook_vars.depth += 1
+        hook_vars.new = new_records
+        hook_vars.old = old_records
+        hook_vars.event = event
+        hook_vars.model = model
+
+        hooks = sorted(get_hooks(model, event), key=lambda x: x[3])
+        logger.debug(f"Found {len(hooks)} hooks for {event}")
+
+        def _execute():
+            logger.debug(f"Executing {len(hooks)} hooks for {event}")
+            new_local = new_records or []
+            old_local = old_records or []
+            if len(old_local) < len(new_local):
+                old_local += [None] * (len(new_local) - len(old_local))
+
+            for handler_cls, method_name, condition, priority in hooks:
+                logger.debug(f"Processing hook {handler_cls.__name__}.{method_name}")
+                if condition is not None:
+                    checks = [
+                        condition.check(n, o) for n, o in zip(new_local, old_local)
+                    ]
+                    if not any(checks):
+                        logger.debug(f"Condition failed for {handler_cls.__name__}.{method_name}")
+                        continue
+
+                handler = handler_cls()
+                method = getattr(handler, method_name)
+                logger.debug(f"Executing {handler_cls.__name__}.{method_name}")
+
+                try:
+                    method(
+                        new_records=new_local,
+                        old_records=old_local,
+                        **kwargs,
+                    )
+                    logger.debug(f"Successfully executed {handler_cls.__name__}.{method_name}")
+                except Exception:
+                    logger.exception(
+                        "Error in hook %s.%s", handler_cls.__name__, method_name
+                    )
+
+        conn = transaction.get_connection()
+        logger.debug(f"Transaction in_atomic_block: {conn.in_atomic_block}, event: {event}")
+        try:
+            if conn.in_atomic_block and event.startswith("after_"):
+                logger.debug(f"Deferring {event} to on_commit")
+                transaction.on_commit(_execute)
+            else:
+                logger.debug(f"Executing {event} immediately")
+                _execute()
+        finally:
+            hook_vars.new = None
+            hook_vars.old = None
+            hook_vars.event = None
+            hook_vars.model = None
+            hook_vars.depth -= 1

django_bulk_hooks/queryset.py

@@ -45,6 +45,21 @@ class HookQuerySetMixin:
         # Then run business logic hooks
         engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
 
+        # Before deletion, ensure all related fields are properly cached
+        # to avoid DoesNotExist errors in AFTER_DELETE hooks
+        for obj in objs:
+            if obj.pk is not None:
+                # Cache all foreign key relationships by accessing them
+                for field in model_cls._meta.fields:
+                    if field.is_relation and not field.many_to_many and not field.one_to_many:
+                        try:
+                            # Access the related field to cache it before deletion
+                            getattr(obj, field.name)
+                        except Exception:
+                            # If we can't access the field (e.g., already deleted, no permission, etc.)
+                            # continue with other fields
+                            pass
+
         # Use Django's standard delete() method
         result = super().delete()
 
@@ -505,9 +520,75 @@ 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
+                
+                # 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
+                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")
@@ -542,9 +623,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
 
@@ -1147,6 +1289,22 @@ class HookQuerySetMixin:
             ctx = HookContext(model_cls, bypass_hooks=True)
             logger.debug("bulk_delete bypassed hooks")
 
+        # Before deletion, ensure all related fields are properly cached
+        # to avoid DoesNotExist errors in AFTER_DELETE hooks
+        if not bypass_hooks:
+            for obj in objs:
+                if obj.pk is not None:
+                    # Cache all foreign key relationships by accessing them
+                    for field in model_cls._meta.fields:
+                        if field.is_relation and not field.many_to_many and not field.one_to_many:
+                            try:
+                                # Access the related field to cache it before deletion
+                                getattr(obj, field.name)
+                            except Exception:
+                                # If we can't access the field (e.g., already deleted, no permission, etc.)
+                                # continue with other fields
+                                pass
+
         # Use Django's standard delete() method on the queryset
         pks = [obj.pk for obj in objs if obj.pk is not None]
         if pks:

{django_bulk_hooks-0.1.250.dist-info → django_bulk_hooks-0.1.252.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.250
+Version: 0.1.252
 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.250.dist-info → django_bulk_hooks-0.1.252.dist-info}/RECORD

@@ -1,17 +1,17 @@
-django_bulk_hooks/__init__.py,sha256=6afmyFwRwC4E9CSWyQdONFJUPl5PeXp3ZuTebd7Ic0Y,158
+django_bulk_hooks/__init__.py,sha256=hsbKduccFEcsV4KIw8CbxCUDOtLZwToCc-XP3sqNy-8,154
 django_bulk_hooks/conditions.py,sha256=V_f3Di2uCVUjoyfiU4BQCHmI4uUIRSRroApDcXlvnso,6349
 django_bulk_hooks/constants.py,sha256=3x1H1fSUUNo0DZONN7GUVDuySZctTR-jtByBHmAIX5w,303
 django_bulk_hooks/context.py,sha256=jlLsqGZbj__J0-iBUp1D6jTrlDEiX3qIo0XlywW4D9I,2244
 django_bulk_hooks/decorators.py,sha256=32ffydS9tARaG_WJoiVri7zJnfS2iMd7SuZ8L_sRAGM,7985
 django_bulk_hooks/engine.py,sha256=M3b7Rcb65PYAZTLfWrIRi99BUBPgSLCryL3MSjMVlfQ,2663
 django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
-django_bulk_hooks/handler.py,sha256=e_GACTQT-pFF-zL7POeo232MgOikUoCLcxDVInAUiBw,6207
+django_bulk_hooks/handler.py,sha256=Bx-W6yyiciKMyy-BRxUt3CmRPCrX9_LhQgU-5LaJTjg,6019
 django_bulk_hooks/manager.py,sha256=nfWiwU5-yAoxdnQsUMohxtyCpkV0MBv6X3wmipr9eQY,3697
 django_bulk_hooks/models.py,sha256=WtSfc4GBOG_oOt8n37cVvid0MtFIGze9JYKSixil2y0,4370
 django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
-django_bulk_hooks/queryset.py,sha256=ZpvXZdUpnYPmjImMrMYWcO7LnTHq41JKPFKnOOpQkqI,52377
+django_bulk_hooks/queryset.py,sha256=whv6QunaxRhos0nBlx600mKeleovjdv3XdeMSULh7n8,60739
 django_bulk_hooks/registry.py,sha256=GRUTGVQEO2sdkC9OaZ9Q3U7mM-3Ix83uTyvrlTtpatw,1317
-django_bulk_hooks-0.1.250.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.250.dist-info/METADATA,sha256=O_7Z0uRR8vvzWw18A0MpILteft0eqRovwwM9U6k7tJg,9049
-django_bulk_hooks-0.1.250.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-django_bulk_hooks-0.1.250.dist-info/RECORD,,
+django_bulk_hooks-0.1.252.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.252.dist-info/METADATA,sha256=xg9nPjRhZJPXem1plWls94mzENbAAoNiWI43J931rpE,9061
+django_bulk_hooks-0.1.252.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.1.252.dist-info/RECORD,,

{django_bulk_hooks-0.1.250.dist-info → django_bulk_hooks-0.1.252.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any