django-bulk-hooks 0.1.227__py3-none-any.whl → 0.1.229__py3-none-any.whl

django_bulk_hooks/queryset.py

@@ -1,6 +1,6 @@
 import logging
 
-from django.db import models, transaction
+from django.db import models, transaction, connections
 from django.db.models import AutoField, Case, Value, When
 from django_bulk_hooks import engine
 from django_bulk_hooks.constants import (
@@ -26,7 +26,7 @@ class HookQuerySetMixin:
     """
 
     @transaction.atomic
-    def delete(self):
+    def delete(self) -> int:
         """
         Delete objects from the database with complete hook support.
 
@@ -61,7 +61,7 @@ class HookQuerySetMixin:
         return result
 
     @transaction.atomic
-    def update(self, **kwargs):
+    def update(self, **kwargs) -> int:
         """
         Update objects with field values and run complete hook cycle.
         
@@ -72,6 +72,7 @@ class HookQuerySetMixin:
         """
         # Extract custom parameters
         bypass_hooks = kwargs.pop('bypass_hooks', False)
+        bypass_validation = kwargs.pop('bypass_validation', False)
         
         instances = list(self)
         if not instances:
@@ -86,41 +87,97 @@ class HookQuerySetMixin:
         }
         originals = [original_map.get(obj.pk) for obj in instances]
 
-        # Check if any of the update values are complex database expressions
-        has_subquery = any(
-            (hasattr(value, "query") and hasattr(value.query, "model"))
-            or (hasattr(value, "get_source_expressions") and value.get_source_expressions())
-            for value in kwargs.values()
-        )
+        # Identify complex database expressions (Subquery, Case, F, CombinedExpression, etc.)
+        complex_fields = {}
+        simple_fields = {}
+        for field_name, value in kwargs.items():
+            is_complex = (
+                (hasattr(value, "query") and hasattr(value.query, "model"))
+                or (
+                    hasattr(value, "get_source_expressions")
+                    and value.get_source_expressions()
+                )
+            )
+            if is_complex:
+                complex_fields[field_name] = value
+            else:
+                simple_fields[field_name] = value
+        has_subquery = bool(complex_fields)
 
         # Run hooks only if not bypassed
         if not bypass_hooks:
+            ctx = HookContext(model_cls)
             # Run VALIDATE_UPDATE hooks
-            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, HookContext(model_cls))
+            if not bypass_validation:
+                engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
+
+            # Resolve complex expressions in one shot per field and apply values
+            if has_subquery:
+                # Build annotations for complex fields
+                annotations = {f"__computed_{name}": expr for name, expr in complex_fields.items()}
+                annotation_aliases = list(annotations.keys())
+                if annotations:
+                    computed_rows = (
+                        model_cls._base_manager.filter(pk__in=pks)
+                        .annotate(**annotations)
+                        .values("pk", *annotation_aliases)
+                    )
+                    computed_map = {}
+                    for row in computed_rows:
+                        pk = row["pk"]
+                        field_values = {}
+                        for fname in complex_fields.keys():
+                            alias = f"__computed_{fname}"
+                            field_values[fname] = row.get(alias)
+                        computed_map[pk] = field_values
+
+                    for instance in instances:
+                        values_for_instance = computed_map.get(instance.pk, {})
+                        for fname, fval in values_for_instance.items():
+                            setattr(instance, fname, fval)
+
+            # Apply simple values directly
+            if simple_fields:
+                for obj in instances:
+                    for field, value in simple_fields.items():
+                        setattr(obj, field, value)
             
-            # Run BEFORE_UPDATE hooks
-            engine.run(model_cls, BEFORE_UPDATE, instances, originals, HookContext(model_cls))
+            # Run BEFORE_UPDATE hooks with updated instances
+            engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
-        if has_subquery:
-            # For complex expressions, use Django's native update
-            # This handles Subquery, Case, F expressions, etc. correctly
-            result = super().update(**kwargs)
-        else:
-            # For simple field updates, apply changes to instances first
-            for obj in instances:
-                for field, value in kwargs.items():
-                    setattr(obj, field, value)
+        # Determine if model uses MTI
+        def _is_mti(m):
+            for parent in m._meta.all_parents:
+                if parent._meta.concrete_model is not m._meta.concrete_model:
+                    return True
+            return False
 
-            # Perform database update using Django's native bulk_update
-            # We use the base manager to avoid recursion
-            base_manager = model_cls._base_manager
+        is_mti = _is_mti(model_cls)
+
+        if is_mti:
+            # Use MTI-aware bulk update across tables
             fields_to_update = list(kwargs.keys())
-            base_manager.bulk_update(instances, fields_to_update)
-            result = len(instances)
+            result = self._mti_bulk_update(instances, fields_to_update)
+        else:
+            if has_subquery:
+                # For complex expressions on single-table models, use Django's native update
+                result = super().update(**kwargs)
+                if not bypass_hooks:
+                    # Reload instances to ensure we have DB-final values
+                    updated_instances = list(model_cls._base_manager.filter(pk__in=pks))
+                    updated_map = {obj.pk: obj for obj in updated_instances}
+                    instances = [updated_map.get(obj.pk, obj) for obj in instances]
+            else:
+                # Simple updates on single-table models
+                base_manager = model_cls._base_manager
+                fields_to_update = list(kwargs.keys())
+                base_manager.bulk_update(instances, fields_to_update)
+                result = len(instances)
 
         # Run AFTER_UPDATE hooks only if not bypassed
         if not bypass_hooks:
-            engine.run(model_cls, AFTER_UPDATE, instances, originals, HookContext(model_cls))
+            ctx = HookContext(model_cls)
+            engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
         
         return result
 
@@ -135,7 +192,7 @@ class HookQuerySetMixin:
         unique_fields=None,
         bypass_hooks=False,
         bypass_validation=False,
-    ):
+    ) -> list:
         """
         Insert each of the instances into the database with complete hook support.
 
@@ -223,7 +280,7 @@ class HookQuerySetMixin:
     @transaction.atomic
     def bulk_update(
         self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
-    ):
+    ) -> int:
         """
         Bulk update objects in the database with complete hook support.
 
@@ -273,29 +330,43 @@ class HookQuerySetMixin:
 
         # Run VALIDATE_UPDATE hooks
         if not bypass_validation:
+            ctx = HookContext(model_cls)
             engine.run(
-                model_cls, VALIDATE_UPDATE, objs, originals, HookContext(model_cls)
+                model_cls, VALIDATE_UPDATE, objs, originals, ctx=ctx
             )
 
         # Run BEFORE_UPDATE hooks
         if not bypass_hooks:
+            ctx = HookContext(model_cls)
             engine.run(
-                model_cls, BEFORE_UPDATE, objs, originals, HookContext(model_cls)
+                model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx
             )
 
-        # Perform database update using Django's native bulk_update
-        # We use the base manager to avoid recursion
-        base_manager = model_cls._base_manager
-        result = base_manager.bulk_update(objs, fields, **kwargs)
+        # Determine if model uses MTI
+        def _is_mti(m):
+            for parent in m._meta.all_parents:
+                if parent._meta.concrete_model is not m._meta.concrete_model:
+                    return True
+            return False
+
+        if _is_mti(model_cls):
+            # Use MTI-aware bulk update across tables
+            result = self._mti_bulk_update(objs, fields, **kwargs)
+        else:
+            # Perform database update using Django's native bulk_update
+            # We use the base manager to avoid recursion
+            base_manager = model_cls._base_manager
+            result = base_manager.bulk_update(objs, fields, **kwargs)
 
         # Run AFTER_UPDATE hooks
         if not bypass_hooks:
-            engine.run(model_cls, AFTER_UPDATE, objs, originals, HookContext(model_cls))
+            ctx = HookContext(model_cls)
+            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
 
         return result
 
     @transaction.atomic
-    def bulk_delete(self, objs, **kwargs):
+    def bulk_delete(self, objs, **kwargs) -> int:
         """
         Delete the given objects from the database with complete hook support.
 
@@ -308,7 +379,7 @@ class HookQuerySetMixin:
         model_cls = self.model
 
         # Extract custom kwargs
-        bypass_hooks = kwargs.pop("bypass_hooks", False)
+        kwargs.pop("bypass_hooks", False)
 
         # Validate inputs
         if not isinstance(objs, (list, tuple)):
@@ -433,50 +504,83 @@ class HookQuerySetMixin:
         # Then we can use Django's bulk_create for the child objects
         parent_objects_map = {}
 
-        # Step 1: Do O(n) normal inserts into parent tables to get primary keys back
-        # Get bypass_hooks from kwargs
+        # Step 1: Insert into parent tables to get primary keys back
         bypass_hooks = kwargs.get("bypass_hooks", False)
         bypass_validation = kwargs.get("bypass_validation", False)
 
-        for obj in batch:
-            parent_instances = {}
-            current_parent = None
+        # If DB supports returning rows from bulk insert, batch per parent model
+        supports_returning = connections[self.db].features.can_return_rows_from_bulk_insert
+
+        if supports_returning:
+            # For each parent level in the chain, create instances in batch preserving order
+            current_parents_per_obj = {id(obj): None for obj in batch}
             for model_class in inheritance_chain[:-1]:
-                parent_obj = self._create_parent_instance(
-                    obj, model_class, current_parent
-                )
+                parent_objs = [
+                    self._create_parent_instance(obj, model_class, current_parents_per_obj[id(obj)])
+                    for obj in batch
+                ]
 
-                # 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
-                }
-                created_obj = model_class._base_manager.using(self.db).create(
-                    **field_values
-                )
+                        engine.run(model_class, VALIDATE_CREATE, parent_objs, ctx=ctx)
+                    engine.run(model_class, BEFORE_CREATE, parent_objs, ctx=ctx)
 
-                # 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
+                # Bulk insert parents using base manager to avoid hook recursion
+                created_parents = model_class._base_manager.using(self.db).bulk_create(
+                    parent_objs, batch_size=len(parent_objs)
+                )
 
-                # Fire AFTER_CREATE hooks for parent
+                # After create hooks
                 if not bypass_hooks:
-                    engine.run(model_class, AFTER_CREATE, [parent_obj], ctx=ctx)
+                    engine.run(model_class, AFTER_CREATE, created_parents, ctx=ctx)
+
+                # Update maps and state for next parent level
+                for obj, parent_obj in zip(batch, created_parents):
+                    # Ensure state reflects saved
+                    parent_obj._state.adding = False
+                    parent_obj._state.db = self.db
+                    # Record for this object and level
+                    if id(obj) not in parent_objects_map:
+                        parent_objects_map[id(obj)] = {}
+                    parent_objects_map[id(obj)][model_class] = parent_obj
+                    current_parents_per_obj[id(obj)] = parent_obj
+        else:
+            # Fallback: per-row parent inserts (original behavior)
+            for obj in batch:
+                parent_instances = {}
+                current_parent = None
+                for model_class in inheritance_chain[:-1]:
+                    parent_obj = self._create_parent_instance(
+                        obj, model_class, current_parent
+                    )
+
+                    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)
+
+                    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
+                    }
+                    created_obj = model_class._base_manager.using(self.db).create(
+                        **field_values
+                    )
+
+                    parent_obj.pk = created_obj.pk
+                    parent_obj._state.adding = False
+                    parent_obj._state.db = self.db
+
+                    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
+                    parent_instances[model_class] = parent_obj
+                    current_parent = parent_obj
+                parent_objects_map[id(obj)] = parent_instances
 
         # Step 2: Create all child objects and do single bulk insert into childmost table
         child_model = inheritance_chain[-1]
@@ -702,7 +806,8 @@ class HookQuerySetMixin:
         # 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
-        root_model = inheritance_chain[0]
+        # Root model (first in chain) has its own PK; kept for clarity
+        # root_model = inheritance_chain[0]
 
         # Get the primary keys from the objects
         # If objects have pk set but are not loaded from DB, use those PKs
@@ -786,7 +891,7 @@ class HookQuerySetMixin:
                         **{f"{filter_field}__in": pks}
                     ).update(**case_statements)
                     total_updated += updated_count
-                except Exception as e:
+                except Exception:
                     import traceback
 
                     traceback.print_exc()

django_bulk_hooks/registry.py

@@ -1,17 +1,28 @@
 import logging
+import threading
 from collections.abc import Callable
-from typing import Union
+from typing import Dict, List, Optional, Tuple, Union
 
 from django_bulk_hooks.priority import Priority
 
 logger = logging.getLogger(__name__)
 
-_hooks: dict[tuple[type, str], list[tuple[type, str, Callable, int]]] = {}
+# Key: (ModelClass, event)
+# Value: list of tuples (handler_cls, method_name, condition_callable, priority)
+_hooks: Dict[Tuple[type, str], List[Tuple[type, str, Callable, int]]] = {}
+
+# Registry lock for thread-safety during registration and clearing
+_lock = threading.RLock()
 
 
 def register_hook(
-    model, event, handler_cls, method_name, condition, priority: Union[int, Priority]
-):
+    model: type,
+    event: str,
+    handler_cls: type,
+    method_name: str,
+    condition: Optional[Callable],
+    priority: Union[int, Priority],
+) -> None:
     """
     Register a hook for a specific model and event.
     
@@ -26,32 +37,47 @@ def register_hook(
     if not model or not event or not handler_cls or not method_name:
         logger.warning("Invalid hook registration parameters")
         return
-    
-    key = (model, event)
-    hooks = _hooks.setdefault(key, [])
-    
-    # Check for duplicate registrations
-    existing = [h for h in hooks if h[0] == handler_cls and h[1] == method_name]
-    if existing:
-        logger.warning(
-            f"Hook {handler_cls.__name__}.{method_name} already registered "
-            f"for {model.__name__}.{event}"
+
+    # Normalize event to str just in case enums are used upstream
+    event = str(event)
+
+    with _lock:
+        key = (model, event)
+        hooks = _hooks.setdefault(key, [])
+
+        # Check for duplicate registrations
+        duplicate = any(h[0] == handler_cls and h[1] == method_name for h in hooks)
+        if duplicate:
+            logger.warning(
+                "Hook %s.%s already registered for %s.%s",
+                handler_cls.__name__,
+                method_name,
+                model.__name__,
+                event,
+            )
+            return
+
+        # Add the hook
+        hooks.append((handler_cls, method_name, condition, priority))
+
+        # Sort by priority (highest numbers execute first)
+        def sort_key(hook_info: Tuple[type, str, Callable, int]) -> int:
+            p = hook_info[3]
+            return p.value if hasattr(p, "value") else int(p)
+
+        hooks.sort(key=sort_key, reverse=True)
+
+        logger.debug(
+            "Registered %s.%s for %s.%s with priority %s",
+            handler_cls.__name__,
+            method_name,
+            model.__name__,
+            event,
+            priority,
         )
-        return
-    
-    # Add the hook
-    hooks.append((handler_cls, method_name, condition, priority))
-    
-    # Sort by priority (lowest numbers execute first, matching engine expectation)
-    hooks.sort(key=lambda x: x[3])
-    
-    logger.debug(
-        f"Registered {handler_cls.__name__}.{method_name} "
-        f"for {model.__name__}.{event} with priority {priority}"
-    )
 
 
-def get_hooks(model, event):
+def get_hooks(model: type, event: str):
     """
     Get all registered hooks for a specific model and event.
     
@@ -64,24 +90,47 @@ def get_hooks(model, event):
     """
     if not model or not event:
         return []
-    
-    key = (model, event)
-    hooks = _hooks.get(key, [])
-    
-    # Log hook discovery for debugging
-    if hooks:
-        logger.debug(f"Found {len(hooks)} hooks for {model.__name__}.{event}")
-    
-    return hooks
 
+    event = str(event)
+
+    with _lock:
+        key = (model, event)
+        hooks = _hooks.get(key, [])
 
-def list_all_hooks():
-    """Debug function to list all registered hooks."""
-    return _hooks
+        # Log hook discovery for debugging
+        if hooks:
+            logger.debug("Found %d hooks for %s.%s", len(hooks), model.__name__, event)
+            for handler_cls, method_name, condition, priority in hooks:
+                logger.debug("  - %s.%s (priority: %s)", handler_cls.__name__, method_name, priority)
+        else:
+            logger.debug("No hooks found for %s.%s", model.__name__, event)
 
+        # Return a shallow copy to prevent external mutation of registry state
+        return list(hooks)
 
-def clear_hooks():
+
+def list_all_hooks() -> Dict[Tuple[type, str], List[Tuple[type, str, Callable, int]]]:
+    """Debug function to list all registered hooks (shallow copy)."""
+    with _lock:
+        return {k: list(v) for k, v in _hooks.items()}
+
+
+def clear_hooks() -> None:
     """Clear all registered hooks (mainly for testing)."""
-    global _hooks
-    _hooks.clear()
-    logger.debug("All hooks cleared")
+    with _lock:
+        _hooks.clear()
+        logger.debug("All hooks cleared")
+
+
+def unregister_hook(model: type, event: str, handler_cls: type, method_name: str) -> None:
+    """Unregister a previously registered hook (safe no-op if not present)."""
+    event = str(event)
+    with _lock:
+        key = (model, event)
+        if key not in _hooks:
+            return
+        _hooks[key] = [
+            h for h in _hooks[key] if not (h[0] == handler_cls and h[1] == method_name)
+        ]
+        if not _hooks[key]:
+            del _hooks[key]

{django_bulk_hooks-0.1.227.dist-info → django_bulk_hooks-0.1.229.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.1.227
+Version: 0.1.229
 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.229.dist-info/RECORD

@@ -0,0 +1,17 @@
+django_bulk_hooks/__init__.py,sha256=uUgpnb9AWjIAcWNpCMqBcOewSnpJjJYH6cjPbQkzoNU,140
+django_bulk_hooks/conditions.py,sha256=7C0enCYMgmIP0WO9Sf_rBbmdHC1yORMELAFoyuBcGgs,7169
+django_bulk_hooks/constants.py,sha256=3x1H1fSUUNo0DZONN7GUVDuySZctTR-jtByBHmAIX5w,303
+django_bulk_hooks/context.py,sha256=L95s1n9N5oBdfdrIA3_zoi0tf7GnDVrQxYaSXPwBkvg,2626
+django_bulk_hooks/decorators.py,sha256=3x16zCsEFIvjg2ld1tUnweH0SWqT0SwrRKRdFs0nC4Y,8523
+django_bulk_hooks/engine.py,sha256=HGAXa9XsG3ilWdoA9rExp6sQZpm02Pkt9CSlq_gRs0I,4974
+django_bulk_hooks/enums.py,sha256=ZSYPwHcjlAMrISOHb9sqNjEfxyv4XupoDoe1hn87VJg,499
+django_bulk_hooks/handler.py,sha256=BKthdeCrgzuLzvy_UUfGLjFFZipAHzuxoelaH6zJVWo,5468
+django_bulk_hooks/manager.py,sha256=uqmvGlskkzKMERf3iexxXCAaQl0v3Wc45BeN-YmfTnE,4060
+django_bulk_hooks/models.py,sha256=1m1POWtfAhWUBrr2uTUEPzBFJpBfAf8WlKUu8muB3z8,6298
+django_bulk_hooks/priority.py,sha256=EGFBbRmX_LhwRYFCKzM8I5m8NGCsUEVJp2pfNTcoHe4,378
+django_bulk_hooks/queryset.py,sha256=u8Abj_W5cABM9pi-vQG_6zGsekbPI6It3tA_zDHUDC4,37480
+django_bulk_hooks/registry.py,sha256=eIjT6xolQYSGbakTOfRDrrc8J6gv0DnYI9rpHAo6XVk,4380
+django_bulk_hooks-0.1.229.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.229.dist-info/METADATA,sha256=1gWbfBTL8ROM7ng-JOB8fawz9xj5v3X1chqLxuApgLM,9743
+django_bulk_hooks-0.1.229.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.1.229.dist-info/RECORD,,

django_bulk_hooks-0.1.227.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=_NbGWTq9s66g0vbFIaqN4GlIHWQmFg3EQ44qY8YvvEg,1537
-django_bulk_hooks/decorators.py,sha256=WD7Jn7QAvY8F4wOsYlIpjoM9-FdHXSKB7hH9ot-lkYQ,4896
-django_bulk_hooks/engine.py,sha256=wiO6HvZkBSHzt1Q3IpXmVppJl30zlsoTheuPPCrGqdU,3118
-django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
-django_bulk_hooks/handler.py,sha256=IRgJ6uoyD1NifqzZpL2YxOqInJ4MFlS3vZkAa5ZTIVo,5210
-django_bulk_hooks/manager.py,sha256=nfWiwU5-yAoxdnQsUMohxtyCpkV0MBv6X3wmipr9eQY,3697
-django_bulk_hooks/models.py,sha256=mj4f93L64CN1XBS29RlS02WnZjCNoUkai97vKqjgZQ8,4575
-django_bulk_hooks/priority.py,sha256=HG_2D35nga68lBCZmSXTcplXrjFoRgZFRDOy4ROKonY,376
-django_bulk_hooks/queryset.py,sha256=xgnuwl8Ha9IhVzKEvjvCX5jUuRZgc0tWYwaKreuDvpw,32478
-django_bulk_hooks/registry.py,sha256=h59veo8Qh4Afj8ZP_4Jqr-2S6ebXjUJ7pJTdfqzfXkE,2572
-django_bulk_hooks-0.1.227.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.227.dist-info/METADATA,sha256=rY5wk0lHKwxaqEdbVz3BLw3DnRBjMhXSN4syZLuWGX4,9743
-django_bulk_hooks-0.1.227.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.1.227.dist-info/RECORD,,