django-bulk-hooks 0.1.238__py3-none-any.whl → 0.1.240__py3-none-any.whl

django_bulk_hooks/__init__.py

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

django_bulk_hooks/decorators.py

@@ -2,6 +2,7 @@ import inspect
 from functools import wraps
 
 from django.core.exceptions import FieldDoesNotExist
+
 from django_bulk_hooks.enums import DEFAULT_PRIORITY
 from django_bulk_hooks.registry import register_hook
 
@@ -61,13 +62,35 @@ def select_related(*related_fields):
                     continue
                 # if any related field is not already cached on the instance,
                 # mark it for fetching
-                if any(field not in obj._state.fields_cache for field in related_fields):
+                if any(
+                    field not in obj._state.fields_cache for field in related_fields
+                ):
                     ids_to_fetch.append(obj.pk)
 
             fetched = {}
             if ids_to_fetch:
-                # Use the base manager to avoid recursion
-                fetched = model_cls._base_manager.select_related(*related_fields).in_bulk(ids_to_fetch)
+                # Validate fields before passing to select_related
+                validated_fields = []
+                for field in related_fields:
+                    if "." in field:
+                        raise ValueError(
+                            f"@select_related does not support nested fields like '{field}'"
+                        )
+                    try:
+                        f = model_cls._meta.get_field(field)
+                        if not (
+                            f.is_relation and not f.many_to_many and not f.one_to_many
+                        ):
+                            continue
+                        validated_fields.append(field)
+                    except FieldDoesNotExist:
+                        continue
+
+                if validated_fields:
+                    # Use the base manager to avoid recursion
+                    fetched = model_cls._base_manager.select_related(
+                        *validated_fields
+                    ).in_bulk(ids_to_fetch)
 
             for obj in new_records:
                 preloaded = fetched.get(obj.pk)
@@ -78,9 +101,8 @@ def select_related(*related_fields):
                         # don't override values that were explicitly set or already loaded
                         continue
                     if "." in field:
-                        raise ValueError(
-                            f"@preload_related does not support nested fields like '{field}'"
-                        )
+                        # This should have been caught earlier, but just in case
+                        continue
 
                     try:
                         f = model_cls._meta.get_field(field)
@@ -108,30 +130,32 @@ def select_related(*related_fields):
 def bulk_hook(model_cls, event, when=None, priority=None):
     """
     Decorator to register a bulk hook for a model.
-    
+
     Args:
         model_cls: The model class to hook into
         event: The event to hook into (e.g., BEFORE_UPDATE, AFTER_UPDATE)
         when: Optional condition for when the hook should run
         priority: Optional priority for hook execution order
     """
+
     def decorator(func):
         # Create a simple handler class for the function
         class FunctionHandler:
             def __init__(self):
                 self.func = func
-            
+
             def handle(self, new_instances, original_instances):
                 return self.func(new_instances, original_instances)
-        
+
         # Register the hook using the registry
         register_hook(
             model=model_cls,
             event=event,
             handler_cls=FunctionHandler,
-            method_name='handle',
+            method_name="handle",
             condition=when,
             priority=priority or DEFAULT_PRIORITY,
         )
         return func
+
     return decorator

django_bulk_hooks/handler.py

@@ -1,167 +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
-
-
-Hook = 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))
-
-        if len(queue) > 1:
-            return  # nested call, will be processed by outermost
-
-        # only outermost handle will process the queue
-        while queue:
-            cls_, event_, model_, new_, old_, kw_ = queue.popleft()
-            cls_._process(event_, model_, new_, old_, **kw_)
-
-    @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])
-
-        def _execute():
-            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:
-                if condition is not None:
-                    checks = [
-                        condition.check(n, o) for n, o in zip(new_local, old_local)
-                    ]
-                    if not any(checks):
-                        continue
-
-                handler = handler_cls()
-                method = getattr(handler, method_name)
-
-                try:
-                    method(
-                        new_records=new_local,
-                        old_records=old_local,
-                        **kwargs,
-                    )
-                except Exception:
-                    logger.exception(
-                        "Error in hook %s.%s", handler_cls.__name__, method_name
-                    )
-
-        conn = transaction.get_connection()
-        try:
-            if conn.in_atomic_block and event.startswith("after_"):
-                transaction.on_commit(_execute)
-            else:
-                _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

@@ -55,6 +55,7 @@ class HookQuerySetMixin:
 
     @transaction.atomic
     def update(self, **kwargs):
+        logger.debug(f"Entering update method with {len(kwargs)} kwargs")
         instances = list(self)
         if not instances:
             return 0
@@ -70,10 +71,38 @@ class HookQuerySetMixin:
         originals = [original_map.get(obj.pk) for obj in instances]
 
         # Check if any of the update values are Subquery objects
-        has_subquery = any(
-            hasattr(value, "query") and hasattr(value, "resolve_expression")
-            for value in kwargs.values()
-        )
+        try:
+            from django.db.models import Subquery
+            logger.debug(f"Successfully imported Subquery from django.db.models")
+        except ImportError as e:
+            logger.error(f"Failed to import Subquery: {e}")
+            raise
+        
+        logger.debug(f"Checking for Subquery objects in {len(kwargs)} kwargs")
+        
+        subquery_detected = []
+        for key, value in kwargs.items():
+            is_subquery = isinstance(value, Subquery)
+            logger.debug(f"Key '{key}': type={type(value).__name__}, is_subquery={is_subquery}")
+            if is_subquery:
+                subquery_detected.append(key)
+        
+        has_subquery = len(subquery_detected) > 0
+        logger.debug(f"Subquery detection result: {has_subquery}, detected keys: {subquery_detected}")
+        
+        # Debug logging for Subquery detection
+        logger.debug(f"Update kwargs: {list(kwargs.keys())}")
+        logger.debug(f"Update kwargs types: {[(k, type(v).__name__) for k, v in kwargs.items()]}")
+        
+        if has_subquery:
+            logger.debug(f"Detected Subquery in update: {[k for k, v in kwargs.items() if isinstance(v, Subquery)]}")
+        else:
+            # Check if we missed any Subquery objects
+            for k, v in kwargs.items():
+                if hasattr(v, 'query') and hasattr(v, 'resolve_expression'):
+                    logger.warning(f"Potential Subquery-like object detected but not recognized: {k}={type(v).__name__}")
+                    logger.warning(f"Object attributes: query={hasattr(v, 'query')}, resolve_expression={hasattr(v, 'resolve_expression')}")
+                    logger.warning(f"Object dir: {[attr for attr in dir(v) if not attr.startswith('_')][:10]}")
 
         # Apply field updates to instances
         # If a per-object value map exists (from bulk_update), prefer it over kwargs
@@ -152,7 +181,49 @@ class HookQuerySetMixin:
 
         # Use Django's built-in update logic directly
         # Call the base QuerySet implementation to avoid recursion
-        update_count = super().update(**kwargs)
+        
+        # Additional safety check: ensure Subquery objects are properly handled
+        # This prevents the "cannot adapt type 'Subquery'" error
+        safe_kwargs = {}
+        logger.debug(f"Processing {len(kwargs)} kwargs for safety check")
+        
+        for key, value in kwargs.items():
+            logger.debug(f"Processing key '{key}' with value type {type(value).__name__}")
+            
+            if isinstance(value, Subquery):
+                logger.debug(f"Found Subquery for field {key}")
+                # Ensure Subquery has proper output_field
+                if not hasattr(value, 'output_field') or value.output_field is None:
+                    logger.warning(f"Subquery for field {key} missing output_field, attempting to infer")
+                    # Try to infer from the model field
+                    try:
+                        field = model_cls._meta.get_field(key)
+                        logger.debug(f"Inferred field type: {type(field).__name__}")
+                        value = value.resolve_expression(None, None)
+                        value.output_field = field
+                        logger.debug(f"Set output_field to {field}")
+                    except Exception as e:
+                        logger.error(f"Failed to infer output_field for Subquery on {key}: {e}")
+                        raise
+                else:
+                    logger.debug(f"Subquery for field {key} already has output_field: {value.output_field}")
+                safe_kwargs[key] = value
+            else:
+                logger.debug(f"Non-Subquery value for field {key}: {type(value).__name__}")
+                safe_kwargs[key] = value
+        
+        logger.debug(f"Safe kwargs keys: {list(safe_kwargs.keys())}")
+        logger.debug(f"Safe kwargs types: {[(k, type(v).__name__) for k, v in safe_kwargs.items()]}")
+        
+        logger.debug(f"Calling super().update() with {len(safe_kwargs)} kwargs")
+        try:
+            update_count = super().update(**safe_kwargs)
+            logger.debug(f"Super update successful, count: {update_count}")
+        except Exception as e:
+            logger.error(f"Super update failed: {e}")
+            logger.error(f"Exception type: {type(e).__name__}")
+            logger.error(f"Safe kwargs that caused failure: {safe_kwargs}")
+            raise
 
         # If we used Subquery objects, refresh the instances to get computed values
         if has_subquery and instances:
@@ -175,8 +246,15 @@ class HookQuerySetMixin:
                                 getattr(refreshed_instance, field.name),
                             )
 
-        # Run AFTER_UPDATE hooks only for standalone updates
-        if not current_bypass_hooks:
+        # Run AFTER_UPDATE hooks for standalone updates or subquery operations
+        # For subquery operations, we need to run hooks even if we're in a bulk context
+        # because subqueries bypass the normal object-level update flow
+        should_run_hooks = (
+            not current_bypass_hooks or 
+            has_subquery  # Always run hooks for subquery operations
+        )
+        
+        if should_run_hooks:
             logger.debug("update: running AFTER_UPDATE")
             engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
         else:
@@ -837,6 +915,49 @@ class HookQuerySetMixin:
 
         return total_updated
 
+    @transaction.atomic
+    def bulk_delete(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
+        """
+        Bulk delete objects in the database.
+        """
+        model_cls = self.model
+
+        if not objs:
+            return 0
+
+        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)}"
+            )
+
+        logger.debug(
+            f"bulk_delete {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}"
+        )
+
+        # Fire hooks before DB ops
+        if not bypass_hooks:
+            ctx = HookContext(model_cls, bypass_hooks=False)
+            if not bypass_validation:
+                engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
+            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
+        else:
+            ctx = HookContext(model_cls, bypass_hooks=True)
+            logger.debug("bulk_delete bypassed hooks")
+
+        # Use Django's standard delete() method on the queryset
+        pks = [obj.pk for obj in objs if obj.pk is not None]
+        if pks:
+            # Use the base manager to avoid recursion
+            result = self.model._base_manager.filter(pk__in=pks).delete()[0]
+        else:
+            result = 0
+
+        # Fire AFTER_DELETE hooks
+        if not bypass_hooks:
+            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
+
+        return result
+
 
 class HookQuerySet(HookQuerySetMixin, models.QuerySet):
     """

django_bulk_hooks/registry.py

@@ -15,7 +15,7 @@ def register_hook(
     key = (model, event)
     hooks = _hooks.setdefault(key, [])
     hooks.append((handler_cls, method_name, condition, priority))
-    # keep sorted by priority
+    # Sort by priority (lower values first)
     hooks.sort(key=lambda x: x[3])
     logger.debug(f"Registered {handler_cls.__name__}.{method_name} for {model.__name__}.{event}")
 
@@ -29,6 +29,13 @@ def get_hooks(model, event):
     return hooks
 
 
+def clear_hooks():
+    """Clear all registered hooks. Useful for testing."""
+    global _hooks
+    _hooks.clear()
+    logger.debug("Cleared all registered hooks")
+
+
 def list_all_hooks():
     """Debug function to list all registered hooks"""
     return _hooks

{django_bulk_hooks-0.1.238.dist-info → django_bulk_hooks-0.1.240.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.238
+Version: 0.1.240
 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.240.dist-info/RECORD

@@ -0,0 +1,17 @@
+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=tBHjegw1qZgpJkKng1q7gMpd2UpSY2nH9f7oD1cWhr0,5735
+django_bulk_hooks/engine.py,sha256=t_kvgex6_iZEFc5LK-srBTZPe-1bdlYdip5LfWOc6lc,2411
+django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
+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=exnXYVKEVbYAXhChCP8VdWTnKCnm9DiTcokEIBee1I0,4350
+django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
+django_bulk_hooks/queryset.py,sha256=bi8jE8yvl2ih0M3LbzW8TZvl7JFKbgysILRXIpci6KM,42055
+django_bulk_hooks/registry.py,sha256=GRUTGVQEO2sdkC9OaZ9Q3U7mM-3Ix83uTyvrlTtpatw,1317
+django_bulk_hooks-0.1.240.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.240.dist-info/METADATA,sha256=hkqwdtVcH2Te0py2ryH-RXgAJpX93e0IDFteueUBYtQ,9061
+django_bulk_hooks-0.1.240.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.1.240.dist-info/RECORD,,

{django_bulk_hooks-0.1.238.dist-info → django_bulk_hooks-0.1.240.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

django_bulk_hooks-0.1.238.dist-info/RECORD

@@ -1,17 +0,0 @@
-django_bulk_hooks/__init__.py,sha256=uUgpnb9AWjIAcWNpCMqBcOewSnpJjJYH6cjPbQkzoNU,140
-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=WD7Jn7QAvY8F4wOsYlIpjoM9-FdHXSKB7hH9ot-lkYQ,4896
-django_bulk_hooks/engine.py,sha256=t_kvgex6_iZEFc5LK-srBTZPe-1bdlYdip5LfWOc6lc,2411
-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=nfWiwU5-yAoxdnQsUMohxtyCpkV0MBv6X3wmipr9eQY,3697
-django_bulk_hooks/models.py,sha256=exnXYVKEVbYAXhChCP8VdWTnKCnm9DiTcokEIBee1I0,4350
-django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
-django_bulk_hooks/queryset.py,sha256=OCKx6sXV1LG-aPOJ4gISjnn4zZzWE-R_NMGbzZF91HY,36156
-django_bulk_hooks/registry.py,sha256=8UuhniiH5ChSeOKV1UUbqTEiIu25bZXvcHmkaRbxmME,1131
-django_bulk_hooks-0.1.238.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.238.dist-info/METADATA,sha256=DHtPWOMH6HjrqO3jx7Ez1JegBVENAxPJISuexntKE-U,9049
-django_bulk_hooks-0.1.238.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-django_bulk_hooks-0.1.238.dist-info/RECORD,,