django-bulk-hooks 0.2.44__py3-none-any.whl → 0.2.93__py3-none-any.whl

django_bulk_hooks/operations/mti_plans.py

@@ -1,96 +1,103 @@
-"""
-MTI operation plans - Data structures for multi-table inheritance operations.
-
-These are pure data structures returned by MTIHandler to be executed by BulkExecutor.
-This separates planning (logic) from execution (database operations).
-"""
-
-from dataclasses import dataclass
-from dataclasses import field
-from typing import Any
-
-
-@dataclass
-class ParentLevel:
-    """
-    Represents one level in the parent hierarchy for MTI bulk create.
-    
-    Attributes:
-        model_class: The parent model class for this level
-        objects: List of parent instances to create
-        original_object_map: Maps parent instance id() -> original object id()
-        update_conflicts: Whether to enable UPSERT for this level
-        unique_fields: Fields for conflict detection (if update_conflicts=True)
-        update_fields: Fields to update on conflict (if update_conflicts=True)
-    """
-    model_class: Any
-    objects: list[Any]
-    original_object_map: dict[int, int] = field(default_factory=dict)
-    update_conflicts: bool = False
-    unique_fields: list[str] = field(default_factory=list)
-    update_fields: list[str] = field(default_factory=list)
-
-
-@dataclass
-class MTICreatePlan:
-    """
-    Plan for executing bulk_create on an MTI model.
-    
-    This plan describes WHAT to create, not HOW to create it.
-    The executor is responsible for executing this plan.
-    
-    Attributes:
-        inheritance_chain: List of model classes from root to child
-        parent_levels: List of ParentLevel objects, one per parent model
-        child_objects: List of child instances to create (not yet with parent links)
-        child_model: The child model class
-        original_objects: Original objects provided by user
-        batch_size: Batch size for operations
-        existing_record_ids: Set of id() of original objects that represent existing DB records
-        update_conflicts: Whether this is an upsert operation
-        unique_fields: Fields used for conflict detection
-        update_fields: Fields to update on conflict
-    """
-    inheritance_chain: list[Any]
-    parent_levels: list[ParentLevel]
-    child_objects: list[Any]
-    child_model: Any
-    original_objects: list[Any]
-    batch_size: int = None
-    existing_record_ids: set = field(default_factory=set)
-    update_conflicts: bool = False
-    unique_fields: list[str] = field(default_factory=list)
-    update_fields: list[str] = field(default_factory=list)
-
-
-@dataclass
-class ModelFieldGroup:
-    """
-    Represents fields to update for one model in the inheritance chain.
-    
-    Attributes:
-        model_class: The model class
-        fields: List of field names to update on this model
-        filter_field: Field to use for filtering (e.g., 'pk' or parent link attname)
-    """
-    model_class: Any
-    fields: list[str]
-    filter_field: str = "pk"
-
-
-@dataclass
-class MTIUpdatePlan:
-    """
-    Plan for executing bulk_update on an MTI model.
-    
-    Attributes:
-        inheritance_chain: List of model classes from root to child
-        field_groups: List of ModelFieldGroup objects
-        objects: Objects to update
-        batch_size: Batch size for operations
-    """
-    inheritance_chain: list[Any]
-    field_groups: list[ModelFieldGroup]
-    objects: list[Any]
-    batch_size: int = None
-
+"""
+MTI operation plans - Data structures for multi-table inheritance operations.
+
+These are pure data structures returned by MTIHandler to be executed by BulkExecutor.
+This separates planning (logic) from execution (database operations).
+"""
+
+from dataclasses import dataclass
+from dataclasses import field
+from typing import Any
+
+
+@dataclass
+class ParentLevel:
+    """
+    Represents one level in the parent hierarchy for MTI bulk create.
+
+    Attributes:
+        model_class: The parent model class for this level
+        objects: List of parent instances to create
+        original_object_map: Maps parent instance id() -> original object id()
+        update_conflicts: Whether to enable UPSERT for this level
+        unique_fields: Fields for conflict detection (if update_conflicts=True)
+        update_fields: Fields to update on conflict (if update_conflicts=True)
+    """
+
+    model_class: Any
+    objects: list[Any]
+    original_object_map: dict[int, int] = field(default_factory=dict)
+    update_conflicts: bool = False
+    unique_fields: list[str] = field(default_factory=list)
+    update_fields: list[str] = field(default_factory=list)
+
+
+@dataclass
+class MTICreatePlan:
+    """
+    Plan for executing bulk_create on an MTI model.
+
+    This plan describes WHAT to create, not HOW to create it.
+    The executor is responsible for executing this plan.
+
+    Attributes:
+        inheritance_chain: List of model classes from root to child
+        parent_levels: List of ParentLevel objects, one per parent model
+        child_objects: List of child instances to create (not yet with parent links)
+        child_model: The child model class
+        original_objects: Original objects provided by user
+        batch_size: Batch size for operations
+        existing_record_ids: Set of id() of original objects that represent existing DB records
+        update_conflicts: Whether this is an upsert operation
+        unique_fields: Fields used for conflict detection (original, unfiltered)
+        update_fields: Fields to update on conflict (original, unfiltered)
+        child_unique_fields: Pre-filtered field objects for child table conflict detection
+        child_update_fields: Pre-filtered field objects for child table updates
+    """
+
+    inheritance_chain: list[Any]
+    parent_levels: list[ParentLevel]
+    child_objects: list[Any]
+    child_model: Any
+    original_objects: list[Any]
+    batch_size: int = None
+    existing_record_ids: set = field(default_factory=set)
+    update_conflicts: bool = False
+    unique_fields: list[str] = field(default_factory=list)
+    update_fields: list[str] = field(default_factory=list)
+    child_unique_fields: list = field(default_factory=list)  # Field objects for child table
+    child_update_fields: list = field(default_factory=list)  # Field objects for child table
+
+
+@dataclass
+class ModelFieldGroup:
+    """
+    Represents fields to update for one model in the inheritance chain.
+
+    Attributes:
+        model_class: The model class
+        fields: List of field names to update on this model
+        filter_field: Field to use for filtering (e.g., 'pk' or parent link attname)
+    """
+
+    model_class: Any
+    fields: list[str]
+    filter_field: str = "pk"
+
+
+@dataclass
+class MTIUpdatePlan:
+    """
+    Plan for executing bulk_update on an MTI model.
+
+    Attributes:
+        inheritance_chain: List of model classes from root to child
+        field_groups: List of ModelFieldGroup objects
+        objects: Objects to update
+        batch_size: Batch size for operations
+    """
+
+    inheritance_chain: list[Any]
+    field_groups: list[ModelFieldGroup]
+    objects: list[Any]
+    batch_size: int = None

django_bulk_hooks/operations/record_classifier.py

@@ -11,13 +11,15 @@ import logging
 
 from django.db.models import Q
 
+from django_bulk_hooks.operations.field_utils import get_field_value_for_db
+
 logger = logging.getLogger(__name__)
 
 
 class RecordClassifier:
     """
     Service for classifying and fetching records via database queries.
-    
+
     This is the SINGLE point of truth for record classification queries.
     Keeps database access logic separate from business/planning logic.
     """
@@ -31,17 +33,18 @@ class RecordClassifier:
         """
         self.model_cls = model_cls
 
-    def classify_for_upsert(self, objs, unique_fields):
+    def classify_for_upsert(self, objs, unique_fields, query_model=None):
         """
         Classify records as new or existing based on unique_fields.
-        
+
         Queries the database to check which records already exist based on the
         unique_fields constraint.
-        
+
         Args:
             objs: List of model instances
             unique_fields: List of field names that form the unique constraint
-            
+            query_model: Optional model class to query (for MTI, may be different from self.model_cls)
+
         Returns:
             Tuple of (existing_record_ids, existing_pks_map)
             - existing_record_ids: Set of id() for objects that exist in DB
@@ -50,6 +53,9 @@ class RecordClassifier:
         if not unique_fields or not objs:
             return set(), {}
 
+        # Use query_model if provided (for MTI scenarios), otherwise use self.model_cls
+        query_model = query_model or self.model_cls
+
         # Build a query to find existing records
         queries = []
         obj_to_unique_values = {}
@@ -57,17 +63,22 @@ class RecordClassifier:
         for obj in objs:
             # Build lookup dict for this object's unique fields
             lookup = {}
+            normalized_values = []
+
             for field_name in unique_fields:
-                value = getattr(obj, field_name, None)
+                # Use centralized field value extraction for consistent FK handling
+                value = get_field_value_for_db(obj, field_name, query_model)
                 if value is None:
                     # Can't match on None values
                     break
                 lookup[field_name] = value
+                normalized_values.append(value)
             else:
                 # All unique fields have values, add to query
                 if lookup:
                     queries.append(Q(**lookup))
-                    obj_to_unique_values[id(obj)] = tuple(lookup.values())
+                    # Store normalized values for comparison with database results
+                    obj_to_unique_values[id(obj)] = tuple(normalized_values)
 
         if not queries:
             return set(), {}
@@ -77,9 +88,12 @@ class RecordClassifier:
         for q in queries[1:]:
             combined_query |= q
 
-        existing_records = list(
-            self.model_cls.objects.filter(combined_query).values("pk", *unique_fields),
-        )
+        logger.info(f"Classifying for upsert: model={query_model.__name__}, query={combined_query}, unique_fields={unique_fields}")
+        queryset = query_model.objects.filter(combined_query)
+        logger.info(f"Queryset SQL: {queryset.query}")
+        logger.info(f"All records in table: {query_model.objects.all().count()}")
+        existing_records = list(queryset.values("pk", *unique_fields))
+        logger.info(f"Found {len(existing_records)} existing records: {existing_records}")
 
         # Map existing records back to original objects
         existing_record_ids = set()
@@ -94,8 +108,7 @@ class RecordClassifier:
                     existing_pks_map[obj_id] = record["pk"]
 
         logger.info(
-            f"Classified {len(existing_record_ids)} existing and "
-            f"{len(objs) - len(existing_record_ids)} new records for upsert",
+            f"Classified {len(existing_record_ids)} existing and {len(objs) - len(existing_record_ids)} new records for upsert",
         )
 
         return existing_record_ids, existing_pks_map
@@ -103,12 +116,12 @@ class RecordClassifier:
     def fetch_by_pks(self, pks, select_related=None, prefetch_related=None):
         """
         Fetch records by primary keys with optional relationship loading.
-        
+
         Args:
             pks: List of primary key values
             select_related: Optional list of fields to select_related
             prefetch_related: Optional list of fields to prefetch_related
-            
+
         Returns:
             Dict[pk, instance] for O(1) lookups
         """
@@ -128,10 +141,10 @@ class RecordClassifier:
     def fetch_by_unique_constraint(self, field_values_map):
         """
         Fetch records matching a unique constraint.
-        
+
         Args:
             field_values_map: Dict of {field_name: value} for unique constraint
-            
+
         Returns:
             Model instance if found, None otherwise
         """
@@ -141,18 +154,17 @@ class RecordClassifier:
             return None
         except self.model_cls.MultipleObjectsReturned:
             logger.warning(
-                f"Multiple {self.model_cls.__name__} records found for "
-                f"unique constraint {field_values_map}",
+                f"Multiple {self.model_cls.__name__} records found for unique constraint {field_values_map}",
             )
             return self.model_cls.objects.filter(**field_values_map).first()
 
     def exists_by_pks(self, pks):
         """
         Check if records exist by primary keys without fetching them.
-        
+
         Args:
             pks: List of primary key values
-            
+
         Returns:
             Set of PKs that exist in the database
         """
@@ -168,13 +180,13 @@ class RecordClassifier:
     def count_by_unique_fields(self, objs, unique_fields):
         """
         Count how many objects already exist based on unique fields.
-        
+
         Useful for validation or reporting before upsert operations.
-        
+
         Args:
             objs: List of model instances
             unique_fields: List of field names that form the unique constraint
-            
+
         Returns:
             Tuple of (existing_count, new_count)
         """

django_bulk_hooks/queryset.py

@@ -11,6 +11,8 @@ import logging
 from django.db import models
 from django.db import transaction
 
+from django_bulk_hooks.helpers import extract_pks
+
 logger = logging.getLogger(__name__)
 
 
@@ -33,6 +35,57 @@ class HookQuerySet(models.QuerySet):
         super().__init__(*args, **kwargs)
         self._coordinator = None
 
+    @classmethod
+    def with_hooks(cls, queryset):
+        """
+        Apply hook functionality to any queryset.
+
+        This enables hooks to work with any manager by applying hook
+        capabilities at the queryset level rather than through inheritance.
+
+        Args:
+            queryset: Any Django QuerySet instance
+
+        Returns:
+            HookQuerySet instance with the same query parameters
+        """
+        if isinstance(queryset, cls):
+            return queryset  # Already has hooks
+
+        # Create a new HookQuerySet with the same parameters as the original queryset
+        hook_qs = cls(
+            model=queryset.model,
+            query=queryset.query,
+            using=queryset._db,
+            hints=getattr(queryset, '_hints', {}),
+        )
+
+        # Preserve any additional attributes from the original queryset
+        # This allows composition with other queryset enhancements
+        cls._preserve_queryset_attributes(hook_qs, queryset)
+
+        return hook_qs
+
+    @classmethod
+    def _preserve_queryset_attributes(cls, hook_qs, original_qs):
+        """
+        Preserve attributes from the original queryset.
+
+        This enables composition with other queryset enhancements like
+        queryable properties, annotations, etc.
+        """
+        # Copy non-method attributes that might be set by other managers
+        for attr_name in dir(original_qs):
+            if (not attr_name.startswith('_') and
+                not hasattr(cls, attr_name) and
+                not callable(getattr(original_qs, attr_name, None))):
+                try:
+                    value = getattr(original_qs, attr_name)
+                    setattr(hook_qs, attr_name, value)
+                except (AttributeError, TypeError):
+                    # Skip attributes that can't be copied
+                    continue
+
     @property
     def coordinator(self):
         """Lazy initialization of coordinator"""
@@ -52,7 +105,6 @@ class HookQuerySet(models.QuerySet):
         update_fields=None,
         unique_fields=None,
         bypass_hooks=False,
-        bypass_validation=False,
     ):
         """
         Create multiple objects with hook support.
@@ -67,7 +119,6 @@ class HookQuerySet(models.QuerySet):
             update_fields=update_fields,
             unique_fields=unique_fields,
             bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
         )
 
     @transaction.atomic
@@ -77,7 +128,6 @@ class HookQuerySet(models.QuerySet):
         fields=None,
         batch_size=None,
         bypass_hooks=False,
-        bypass_validation=False,
         **kwargs,
     ):
         """
@@ -90,7 +140,6 @@ class HookQuerySet(models.QuerySet):
             fields: List of field names to update (optional, will auto-detect if None)
             batch_size: Number of objects per batch
             bypass_hooks: Skip all hooks if True
-            bypass_validation: Skip validation hooks if True
 
         Returns:
             Number of objects updated
@@ -106,11 +155,10 @@ class HookQuerySet(models.QuerySet):
             fields=fields,
             batch_size=batch_size,
             bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
         )
 
     @transaction.atomic
-    def update(self, bypass_hooks=False, bypass_validation=False, **kwargs):
+    def update(self, bypass_hooks=False, **kwargs):
         """
         Update QuerySet with hook support.
 
@@ -118,7 +166,6 @@ class HookQuerySet(models.QuerySet):
 
         Args:
             bypass_hooks: Skip all hooks if True
-            bypass_validation: Skip validation hooks if True
             **kwargs: Fields to update
 
         Returns:
@@ -127,12 +174,14 @@ class HookQuerySet(models.QuerySet):
         return self.coordinator.update_queryset(
             update_kwargs=kwargs,
             bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
         )
 
     @transaction.atomic
     def bulk_delete(
-        self, objs, bypass_hooks=False, bypass_validation=False, **kwargs,
+        self,
+        objs,
+        bypass_hooks=False,
+        **kwargs,
     ):
         """
         Delete multiple objects with hook support.
@@ -142,13 +191,12 @@ class HookQuerySet(models.QuerySet):
         Args:
             objs: List of objects to delete
             bypass_hooks: Skip all hooks if True
-            bypass_validation: Skip validation hooks if True
 
         Returns:
             Tuple of (count, details dict)
         """
         # Filter queryset to only these objects
-        pks = [obj.pk for obj in objs if obj.pk is not None]
+        pks = extract_pks(objs)
         if not pks:
             return 0
 
@@ -162,14 +210,13 @@ class HookQuerySet(models.QuerySet):
 
         count, details = coordinator.delete(
             bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
         )
 
         # For bulk_delete, return just the count to match Django's behavior
         return count
 
     @transaction.atomic
-    def delete(self, bypass_hooks=False, bypass_validation=False):
+    def delete(self, bypass_hooks=False):
         """
         Delete QuerySet with hook support.
 
@@ -177,12 +224,10 @@ class HookQuerySet(models.QuerySet):
 
         Args:
             bypass_hooks: Skip all hooks if True
-            bypass_validation: Skip validation hooks if True
 
         Returns:
             Tuple of (count, details dict)
         """
         return self.coordinator.delete(
             bypass_hooks=bypass_hooks,
-            bypass_validation=bypass_validation,
         )

django_bulk_hooks/registry.py

@@ -116,7 +116,6 @@ class HookRegistry:
             if not self._hooks[key]:
                 del self._hooks[key]
 
-
     def clear(self) -> None:
         """
         Clear all registered hooks.
@@ -132,7 +131,6 @@ class HookRegistry:
             HookMeta._registered.clear()
             HookMeta._class_hook_map.clear()
 
-
     def list_all(self) -> dict[tuple[type, str], list[HookInfo]]:
         """
         Get all registered hooks for debugging.

{django_bulk_hooks-0.2.44.dist-info → django_bulk_hooks-0.2.93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.44
+Version: 0.2.93
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks
@@ -244,17 +244,68 @@ LoanAccount.objects.bulk_update(reordered)  # fields are auto-detected
 
 ## 🧩 Integration with Other Managers
 
-You can extend from `BulkHookManager` to work with other manager classes. The manager uses a cooperative approach that dynamically injects bulk hook functionality into any queryset, ensuring compatibility with other managers.
+### Recommended: QuerySet-based Composition (New Approach)
+
+For the best compatibility and to avoid inheritance conflicts, use the queryset-based composition approach:
+
+```python
+from django_bulk_hooks.queryset import HookQuerySet
+from queryable_properties.managers import QueryablePropertiesManager
+
+class MyManager(QueryablePropertiesManager):
+    """Manager that combines queryable properties with hooks"""
+
+    def get_queryset(self):
+        # Get the QueryableProperties QuerySet
+        qs = super().get_queryset()
+        # Apply hooks on top of it
+        return HookQuerySet.with_hooks(qs)
+
+class Article(models.Model):
+    title = models.CharField(max_length=100)
+    published = models.BooleanField(default=False)
+
+    objects = MyManager()
+
+# This gives you both queryable properties AND hooks
+# No inheritance conflicts, no MRO issues!
+```
+
+### Alternative: Explicit Hook Application
+
+For more control, you can apply hooks explicitly:
+
+```python
+class MyManager(QueryablePropertiesManager):
+    def get_queryset(self):
+        return super().get_queryset()
+
+    def with_hooks(self):
+        """Apply hooks to this queryset"""
+        return HookQuerySet.with_hooks(self.get_queryset())
+
+# Usage:
+Article.objects.with_hooks().filter(published=True).update(title="Updated")
+```
+
+### Legacy: Manager Inheritance (Not Recommended)
+
+The old inheritance approach still works but is not recommended due to potential MRO conflicts:
 
 ```python
 from django_bulk_hooks.manager import BulkHookManager
 from queryable_properties.managers import QueryablePropertiesManager
 
 class MyManager(BulkHookManager, QueryablePropertiesManager):
-    pass
+    pass  # ⚠️ Can cause inheritance conflicts
 ```
 
-This approach uses the industry-standard injection pattern, similar to how `QueryablePropertiesManager` works, ensuring both functionalities work seamlessly together without any framework-specific knowledge.
+**Why the new approach is better:**
+- ✅ No inheritance conflicts
+- ✅ No MRO (Method Resolution Order) issues
+- ✅ Works with any manager combination
+- ✅ Cleaner and more maintainable
+- ✅ Follows Django's queryset enhancement patterns
 
 Framework needs to:
 Register these methods

django_bulk_hooks-0.2.93.dist-info/RECORD

@@ -0,0 +1,27 @@
+django_bulk_hooks/__init__.py,sha256=ZKjEi9Sj3lRr3hcEfknXAr1UXXwERzUCNgMkNXhW0mk,2119
+django_bulk_hooks/changeset.py,sha256=qnMD3bR2cNh8ZM8J6ASR5ly5Rjx-tPzXBYkqIjKGW98,6568
+django_bulk_hooks/conditions.py,sha256=ar4pGjtxLKmgSIlO4S6aZFKmaBNchLtxMmWpkn4g9RU,8114
+django_bulk_hooks/constants.py,sha256=PxpEETaO6gdENcTPoXS586lerGKVP3nmjpDvOkmhYxI,509
+django_bulk_hooks/context.py,sha256=mqaC5-yESDTA5ruI7fuXlt8qSgKuOFp0mjq7h1-4HdQ,1926
+django_bulk_hooks/decorators.py,sha256=TdkO4FJyFrVU2zqK6Y_6JjEJ4v3nbKkk7aa22jN10sk,11994
+django_bulk_hooks/dispatcher.py,sha256=IjRAEQmWIiTqyan3hWlnV3rnjM0CYSVRmXc1xNUWWU8,24085
+django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
+django_bulk_hooks/factory.py,sha256=ezrVM5U023KZqOBbJXb6lYUP-pE7WJmi8Olh2Ew-7RA,18085
+django_bulk_hooks/handler.py,sha256=SRCrMzgolrruTkvMnYBFmXLR-ABiw0JiH3605PEdCZM,4207
+django_bulk_hooks/helpers.py,sha256=3rH9TJkdCPF7Vu--0tDaZzJg9Yxcv7yoSF1K1_-0psQ,8048
+django_bulk_hooks/manager.py,sha256=sn4ALCuxRydjIJ91kB81Dhj4PitwytGa4wzxPos4I2Q,4096
+django_bulk_hooks/models.py,sha256=H16AuIiRjkwTD-YDA9S_sMYfAzAFoBgKqiq4TvJuJ9M,3325
+django_bulk_hooks/operations/__init__.py,sha256=BtJYjmRhe_sScivLsniDaZmBkm0ZLvcmzXFKL7QY2Xg,550
+django_bulk_hooks/operations/analyzer.py,sha256=Fw4rjkhpfT8b2A4c7CSMfFRtLUFVimCCz_eGIBtcNiI,15126
+django_bulk_hooks/operations/bulk_executor.py,sha256=FEhC8IsjvPcTXMMNvxc3w3CB1c49mKqQ-Jq02QY5yLM,28263
+django_bulk_hooks/operations/coordinator.py,sha256=3n9bKpcn3_X-zos0tYX6JWS77JleeYMVawZu2DZ1LC4,34973
+django_bulk_hooks/operations/field_utils.py,sha256=EM7y3Vs_4zn-ejgHee6MaenYEhL5txN13kB5cqFHIN0,14109
+django_bulk_hooks/operations/mti_handler.py,sha256=00djtjfZ0rrOfiEii8TS1aBarC0qDpCBsFfWGrljvsc,26946
+django_bulk_hooks/operations/mti_plans.py,sha256=HIRJgogHPpm6MV7nZZ-sZhMLUnozpZPV2SzwQHLRzYc,3667
+django_bulk_hooks/operations/record_classifier.py,sha256=It85hJC2K-UsEOLbTR-QBdY5UPV-acQIJ91TSGa7pYo,7053
+django_bulk_hooks/queryset.py,sha256=tPIkNESb47fTIpTrR6xUtc-k3gCFR15W0Xt2-HmvlJo,6811
+django_bulk_hooks/registry.py,sha256=4HxP1mVK2z4VzvlohbEw2359wM21UJZJYagJJ1komM0,7947
+django_bulk_hooks-0.2.93.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.2.93.dist-info/METADATA,sha256=ewuQ9Igpa9y-NNo3UFbmPtu2lDRFO1cUndjdQQD3FR4,10555
+django_bulk_hooks-0.2.93.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.2.93.dist-info/RECORD,,