django-bulk-hooks 0.1.85__py3-none-any.whl → 0.1.87__py3-none-any.whl

django_bulk_hooks/conditions.py

@@ -195,90 +195,86 @@ class HookCondition:
     def __invert__(self):
         return NotCondition(self)
 
+    def get_required_fields(self):
+        """
+        Returns a set of field names that this condition needs to evaluate.
+        Override in subclasses to specify required fields.
+        """
+        return set()
 
-class IsNotEqual(HookCondition):
-    def __init__(self, field, value, only_on_change=False):
+
+class IsEqual(HookCondition):
+    def __init__(self, field, value):
         self.field = field
         self.value = value
-        self.only_on_change = only_on_change
 
     def check(self, instance, original_instance=None):
-        current = resolve_dotted_attr(instance, self.field)
-        if self.only_on_change:
-            if original_instance is None:
-                return False
-            previous = resolve_dotted_attr(original_instance, self.field)
-            return previous == self.value and current != self.value
-        else:
-            return current != self.value
+        current_value = resolve_dotted_attr(instance, self.field)
+        return current_value == self.value
 
+    def get_required_fields(self):
+        return {self.field.split('.')[0]}
 
-class IsEqual(HookCondition):
-    def __init__(self, field, value, only_on_change=False):
+
+class IsNotEqual(HookCondition):
+    def __init__(self, field, value):
         self.field = field
         self.value = value
-        self.only_on_change = only_on_change
 
     def check(self, instance, original_instance=None):
-        current = resolve_dotted_attr(instance, self.field)
-        if self.only_on_change:
-            if original_instance is None:
-                return False
-            previous = resolve_dotted_attr(original_instance, self.field)
-            return previous != self.value and current == self.value
-        else:
-            return current == self.value
+        current_value = resolve_dotted_attr(instance, self.field)
+        return current_value != self.value
 
+    def get_required_fields(self):
+        return {self.field.split('.')[0]}
 
-class HasChanged(HookCondition):
-    def __init__(self, field, has_changed=True):
+
+class WasEqual(HookCondition):
+    def __init__(self, field, value):
         self.field = field
-        self.has_changed = has_changed
+        self.value = value
 
     def check(self, instance, original_instance=None):
-        if not original_instance:
+        if original_instance is None:
             return False
-        current = resolve_dotted_attr(instance, self.field)
-        previous = resolve_dotted_attr(original_instance, self.field)
-        return (current != previous) == self.has_changed
+        original_value = resolve_dotted_attr(original_instance, self.field)
+        return original_value == self.value
 
+    def get_required_fields(self):
+        return {self.field.split('.')[0]}
 
-class WasEqual(HookCondition):
-    def __init__(self, field, value, only_on_change=False):
-        """
-        Check if a field's original value was `value`.
-        If only_on_change is True, only return True when the field has changed away from that value.
-        """
+
+class HasChanged(HookCondition):
+    def __init__(self, field):
         self.field = field
-        self.value = value
-        self.only_on_change = only_on_change
 
     def check(self, instance, original_instance=None):
         if original_instance is None:
-            return False
-        previous = resolve_dotted_attr(original_instance, self.field)
-        if self.only_on_change:
-            current = resolve_dotted_attr(instance, self.field)
-            return previous == self.value and current != self.value
-        else:
-            return previous == self.value
+            return True
+        current_value = resolve_dotted_attr(instance, self.field)
+        original_value = resolve_dotted_attr(original_instance, self.field)
+        return current_value != original_value
+
+    def get_required_fields(self):
+        return {self.field.split('.')[0]}
 
 
 class ChangesTo(HookCondition):
     def __init__(self, field, value):
-        """
-        Check if a field's value has changed to `value`.
-        Only returns True when original value != value and current value == value.
-        """
         self.field = field
         self.value = value
 
     def check(self, instance, original_instance=None):
         if original_instance is None:
-            return False
-        previous = resolve_dotted_attr(original_instance, self.field)
-        current = resolve_dotted_attr(instance, self.field)
-        return previous != self.value and current == self.value
+            current_value = resolve_dotted_attr(instance, self.field)
+            return current_value == self.value
+
+        current_value = resolve_dotted_attr(instance, self.field)
+        original_value = resolve_dotted_attr(original_instance, self.field)
+        return current_value == self.value and current_value != original_value
+
+    def get_required_fields(self):
+        return {self.field.split('.')[0]}
 
 
 class IsGreaterThan(HookCondition):
@@ -322,30 +318,41 @@ class IsLessThanOrEqual(HookCondition):
 
 
 class AndCondition(HookCondition):
-    def __init__(self, cond1, cond2):
-        self.cond1 = cond1
-        self.cond2 = cond2
+    def __init__(self, condition1, condition2):
+        self.condition1 = condition1
+        self.condition2 = condition2
 
     def check(self, instance, original_instance=None):
-        return self.cond1.check(instance, original_instance) and self.cond2.check(
-            instance, original_instance
+        return (
+            self.condition1.check(instance, original_instance)
+            and self.condition2.check(instance, original_instance)
         )
 
+    def get_required_fields(self):
+        return self.condition1.get_required_fields() | self.condition2.get_required_fields()
+
 
 class OrCondition(HookCondition):
-    def __init__(self, cond1, cond2):
-        self.cond1 = cond1
-        self.cond2 = cond2
+    def __init__(self, condition1, condition2):
+        self.condition1 = condition1
+        self.condition2 = condition2
 
     def check(self, instance, original_instance=None):
-        return self.cond1.check(instance, original_instance) or self.cond2.check(
-            instance, original_instance
+        return (
+            self.condition1.check(instance, original_instance)
+            or self.condition2.check(instance, original_instance)
         )
 
+    def get_required_fields(self):
+        return self.condition1.get_required_fields() | self.condition2.get_required_fields()
+
 
 class NotCondition(HookCondition):
-    def __init__(self, cond):
-        self.cond = cond
+    def __init__(self, condition):
+        self.condition = condition
 
     def check(self, instance, original_instance=None):
-        return not self.cond.check(instance, original_instance)
+        return not self.condition.check(instance, original_instance)
+
+    def get_required_fields(self):
+        return self.condition.get_required_fields()

django_bulk_hooks/engine.py

@@ -8,7 +8,12 @@ from django_bulk_hooks.conditions import safe_get_related_object, safe_get_relat
 logger = logging.getLogger(__name__)
 
 
+# Cache for hook handlers to avoid creating them repeatedly
+_handler_cache = {}
+
 def run(model_cls, event, new_instances, original_instances=None, ctx=None):
+    # Get hooks from cache or fetch them
+    cache_key = (model_cls, event)
     hooks = get_hooks(model_cls, event)
 
     if not hooks:
@@ -32,19 +37,32 @@ def run(model_cls, event, new_instances, original_instances=None, ctx=None):
                     logger.error("Unexpected error during validation for %s: %s", instance, e)
                     raise
 
+    # Pre-create None list for originals if needed
+    if original_instances is None:
+        original_instances = [None] * len(new_instances)
+
+    # Process all hooks
     for handler_cls, method_name, condition, priority in hooks:
-        handler_instance = handler_cls()
-        func = getattr(handler_instance, method_name)
+        # Get or create handler instance from cache
+        handler_key = (handler_cls, method_name)
+        if handler_key not in _handler_cache:
+            handler_instance = handler_cls()
+            func = getattr(handler_instance, method_name)
+            _handler_cache[handler_key] = (handler_instance, func)
+        else:
+            handler_instance, func = _handler_cache[handler_key]
+
+        # If no condition, process all instances at once
+        if not condition:
+            func(new_records=new_instances, old_records=original_instances if any(original_instances) else None)
+            continue
 
+        # For conditional hooks, filter instances first
         to_process_new = []
         to_process_old = []
 
-        for new, original in zip(
-            new_instances,
-            original_instances or [None] * len(new_instances),
-            strict=True,
-        ):
-            if not condition or condition.check(new, original):
+        for new, original in zip(new_instances, original_instances, strict=True):
+            if condition.check(new, original):
                 to_process_new.append(new)
                 to_process_old.append(original)
 

django_bulk_hooks/manager.py

@@ -17,15 +17,82 @@ from django_bulk_hooks.queryset import HookQuerySet
 
 
 class BulkHookManager(models.Manager):
-    CHUNK_SIZE = 200
-
-    def get_queryset(self):
-        return HookQuerySet(self.model, using=self._db)
+    # Default chunk sizes - can be overridden per model
+    DEFAULT_CHUNK_SIZE = 200
+    DEFAULT_RELATED_CHUNK_SIZE = 500  # Higher for related object fetching
+    
+    def __init__(self):
+        super().__init__()
+        self._chunk_size = self.DEFAULT_CHUNK_SIZE
+        self._related_chunk_size = self.DEFAULT_RELATED_CHUNK_SIZE
+        self._prefetch_related_fields = set()
+        self._select_related_fields = set()
+
+    def configure(self, chunk_size=None, related_chunk_size=None, 
+                 select_related=None, prefetch_related=None):
+        """
+        Configure bulk operation parameters for this manager.
+        
+        Args:
+            chunk_size: Number of objects to process in each bulk operation chunk
+            related_chunk_size: Number of objects to fetch in each related object query
+            select_related: List of fields to always select_related in bulk operations
+            prefetch_related: List of fields to always prefetch_related in bulk operations
+        """
+        if chunk_size is not None:
+            self._chunk_size = chunk_size
+        if related_chunk_size is not None:
+            self._related_chunk_size = related_chunk_size
+        if select_related:
+            self._select_related_fields.update(select_related)
+        if prefetch_related:
+            self._prefetch_related_fields.update(prefetch_related)
+
+    def _load_originals_optimized(self, pks, fields_to_fetch=None):
+        """
+        Optimized loading of original instances with smart batching and field selection.
+        """
+        queryset = self.model.objects.filter(pk__in=pks)
+        
+        # Only select specific fields if provided
+        if fields_to_fetch:
+            queryset = queryset.only('pk', *fields_to_fetch)
+            
+        # Apply configured related field optimizations
+        if self._select_related_fields:
+            queryset = queryset.select_related(*self._select_related_fields)
+        if self._prefetch_related_fields:
+            queryset = queryset.prefetch_related(*self._prefetch_related_fields)
+            
+        # Batch load in chunks to avoid memory issues
+        all_originals = []
+        for i in range(0, len(pks), self._related_chunk_size):
+            chunk_pks = pks[i:i + self._related_chunk_size]
+            chunk_originals = list(queryset.filter(pk__in=chunk_pks))
+            all_originals.extend(chunk_originals)
+            
+        return all_originals
+
+    def _get_fields_to_fetch(self, objs, fields):
+        """
+        Determine which fields need to be fetched based on what's being updated
+        and what's needed for hooks.
+        """
+        fields_to_fetch = set(fields)
+        
+        # Add fields needed by registered hooks
+        from django_bulk_hooks.registry import get_hooks
+        hooks = get_hooks(self.model, "before_update") + get_hooks(self.model, "after_update")
+        
+        for handler_cls, method_name, condition, _ in hooks:
+            if condition:
+                # If there's a condition, we need all fields it might access
+                fields_to_fetch.update(condition.get_required_fields())
+                
+        return fields_to_fetch
 
     @transaction.atomic
-    def bulk_update(
-        self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
-    ):
+    def bulk_update(self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs):
         if not objs:
             return []
 
@@ -37,35 +104,42 @@ class BulkHookManager(models.Manager):
             )
 
         if not bypass_hooks:
-            # Load originals for hook comparison
-            originals = list(
-                model_cls.objects.filter(pk__in=[obj.pk for obj in objs])
-            )
+            # Determine which fields we need to fetch
+            fields_to_fetch = self._get_fields_to_fetch(objs, fields)
+            
+            # Load originals efficiently
+            pks = [obj.pk for obj in objs if obj.pk is not None]
+            originals = self._load_originals_optimized(pks, fields_to_fetch)
+            
+            # Create a mapping for quick lookup
+            original_map = {obj.pk: obj for obj in originals}
+            
+            # Align originals with new instances
+            aligned_originals = [original_map.get(obj.pk) for obj in objs]
 
             ctx = HookContext(model_cls)
 
             # Run validation hooks first
             if not bypass_validation:
-                engine.run(model_cls, VALIDATE_UPDATE, objs, originals, ctx=ctx)
+                engine.run(model_cls, VALIDATE_UPDATE, objs, aligned_originals, ctx=ctx)
 
             # Then run business logic hooks
-            engine.run(model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx)
+            engine.run(model_cls, BEFORE_UPDATE, objs, aligned_originals, ctx=ctx)
 
             # Automatically detect fields that were modified during BEFORE_UPDATE hooks
-            modified_fields = self._detect_modified_fields(objs, originals)
+            modified_fields = self._detect_modified_fields(objs, aligned_originals)
             if modified_fields:
-                # Convert to set for efficient union operation
                 fields_set = set(fields)
                 fields_set.update(modified_fields)
                 fields = list(fields_set)
 
-        for i in range(0, len(objs), self.CHUNK_SIZE):
-            chunk = objs[i : i + self.CHUNK_SIZE]
-            # Call the base implementation to avoid re-triggering this method
+        # Process in chunks
+        for i in range(0, len(objs), self._chunk_size):
+            chunk = objs[i:i + self._chunk_size]
             super(models.Manager, self).bulk_update(chunk, fields, **kwargs)
 
         if not bypass_hooks:
-            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
+            engine.run(model_cls, AFTER_UPDATE, objs, aligned_originals, ctx=ctx)
 
         return objs
 
@@ -114,42 +188,52 @@ class BulkHookManager(models.Manager):
 
     @transaction.atomic
     def bulk_create(self, objs, bypass_hooks=False, bypass_validation=False, **kwargs):
+        if not objs:
+            return []
+
         model_cls = self.model
+        result = []
 
         if any(not isinstance(obj, model_cls) for obj in objs):
             raise TypeError(
                 f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        result = []
-
         if not bypass_hooks:
             ctx = HookContext(model_cls)
 
-            # Run validation hooks first
+            # Process validation in chunks to avoid memory issues
             if not bypass_validation:
-                engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
+                for i in range(0, len(objs), self._chunk_size):
+                    chunk = objs[i:i + self._chunk_size]
+                    engine.run(model_cls, VALIDATE_CREATE, chunk, ctx=ctx)
 
-            # Then run business logic hooks
-            engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
+            # Process before_create hooks in chunks
+            for i in range(0, len(objs), self._chunk_size):
+                chunk = objs[i:i + self._chunk_size]
+                engine.run(model_cls, BEFORE_CREATE, chunk, ctx=ctx)
 
-        for i in range(0, len(objs), self.CHUNK_SIZE):
-            chunk = objs[i : i + self.CHUNK_SIZE]
-            result.extend(super(models.Manager, self).bulk_create(chunk, **kwargs))
+        # Perform bulk create in chunks
+        for i in range(0, len(objs), self._chunk_size):
+            chunk = objs[i:i + self._chunk_size]
+            created_chunk = super(models.Manager, self).bulk_create(chunk, **kwargs)
+            result.extend(created_chunk)
 
         if not bypass_hooks:
-            engine.run(model_cls, AFTER_CREATE, result, ctx=ctx)
+            # Process after_create hooks in chunks
+            for i in range(0, len(result), self._chunk_size):
+                chunk = result[i:i + self._chunk_size]
+                engine.run(model_cls, AFTER_CREATE, chunk, ctx=ctx)
 
         return result
 
     @transaction.atomic
-    def bulk_delete(
-        self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False
-    ):
+    def bulk_delete(self, objs, batch_size=None, bypass_hooks=False, bypass_validation=False):
         if not objs:
             return []
 
         model_cls = self.model
+        chunk_size = batch_size or self._chunk_size
 
         if any(not isinstance(obj, model_cls) for obj in objs):
             raise TypeError(
@@ -159,21 +243,25 @@ class BulkHookManager(models.Manager):
         ctx = HookContext(model_cls)
 
         if not bypass_hooks:
-            # Run validation hooks first
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_DELETE, objs, ctx=ctx)
-
-            # Then run business logic hooks
-            engine.run(model_cls, BEFORE_DELETE, objs, ctx=ctx)
-
+            # Process hooks in chunks
+            for i in range(0, len(objs), chunk_size):
+                chunk = objs[i:i + chunk_size]
+                
+                if not bypass_validation:
+                    engine.run(model_cls, VALIDATE_DELETE, chunk, ctx=ctx)
+                engine.run(model_cls, BEFORE_DELETE, chunk, ctx=ctx)
+
+        # Collect PKs and delete in chunks
         pks = [obj.pk for obj in objs if obj.pk is not None]
-        
-        # Use base manager for the actual deletion to prevent recursion
-        # The hooks have already been fired above, so we don't need them again
-        model_cls._base_manager.filter(pk__in=pks).delete()
+        for i in range(0, len(pks), chunk_size):
+            chunk_pks = pks[i:i + chunk_size]
+            model_cls._base_manager.filter(pk__in=chunk_pks).delete()
 
         if not bypass_hooks:
-            engine.run(model_cls, AFTER_DELETE, objs, ctx=ctx)
+            # Process after_delete hooks in chunks
+            for i in range(0, len(objs), chunk_size):
+                chunk = objs[i:i + chunk_size]
+                engine.run(model_cls, AFTER_DELETE, chunk, ctx=ctx)
 
         return objs
 

django_bulk_hooks/models.py

@@ -91,40 +91,24 @@ class HookModelMixin(models.Model):
         is_create = self.pk is None
         ctx = HookContext(self.__class__)
 
-        if is_create:
-            # For create operations, run BEFORE hooks first
-            with patch_foreign_key_behavior():
+        # Use a single context manager for all hooks
+        with patch_foreign_key_behavior():
+            if is_create:
+                # For create operations
                 run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-            
-            # Then let Django save
-            super().save(*args, **kwargs)
-            
-            # Then run AFTER hooks
-            with patch_foreign_key_behavior():
+                super().save(*args, **kwargs)
                 run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
-        else:
-            # For update operations, we need to get the old record
-            try:
-                old_instance = self.__class__.objects.get(pk=self.pk)
-                
-                # Run BEFORE hooks first
-                with patch_foreign_key_behavior():
+            else:
+                # For update operations
+                try:
+                    old_instance = self.__class__.objects.get(pk=self.pk)
                     run(self.__class__, BEFORE_UPDATE, [self], [old_instance], ctx=ctx)
-                
-                # Then let Django save
-                super().save(*args, **kwargs)
-                
-                # Then run AFTER hooks
-                with patch_foreign_key_behavior():
+                    super().save(*args, **kwargs)
                     run(self.__class__, AFTER_UPDATE, [self], [old_instance], ctx=ctx)
-            except self.__class__.DoesNotExist:
-                # If the old instance doesn't exist, treat as create
-                with patch_foreign_key_behavior():
+                except self.__class__.DoesNotExist:
+                    # If the old instance doesn't exist, treat as create
                     run(self.__class__, BEFORE_CREATE, [self], ctx=ctx)
-                
-                super().save(*args, **kwargs)
-                
-                with patch_foreign_key_behavior():
+                    super().save(*args, **kwargs)
                     run(self.__class__, AFTER_CREATE, [self], ctx=ctx)
 
         return self
@@ -132,16 +116,11 @@ class HookModelMixin(models.Model):
     def delete(self, *args, **kwargs):
         ctx = HookContext(self.__class__)
 
-        # Run validation hooks first
+        # Use a single context manager for all hooks
         with patch_foreign_key_behavior():
             run(self.__class__, VALIDATE_DELETE, [self], ctx=ctx)
-
-        # Then run business logic hooks
-        with patch_foreign_key_behavior():
             run(self.__class__, BEFORE_DELETE, [self], ctx=ctx)
-
-        result = super().delete(*args, **kwargs)
-
-        with patch_foreign_key_behavior():
+            result = super().delete(*args, **kwargs)
             run(self.__class__, AFTER_DELETE, [self], ctx=ctx)
+            
         return result

{django_bulk_hooks-0.1.85.dist-info → django_bulk_hooks-0.1.87.dist-info}/METADATA

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

@@ -1,16 +1,16 @@
 django_bulk_hooks/__init__.py,sha256=2PcJ6xz7t7Du0nmLO_5732G6u_oZTygogG0fKESRHHk,1082
-django_bulk_hooks/conditions.py,sha256=cif5R4C_N2HosuYiB03STc2rHb800EJV0Nby-ZPac1s,12460
+django_bulk_hooks/conditions.py,sha256=tAhXwAMqoy5vhcVb_MPmNylVCjdNsDi-XBaEkyqF1xs,12391
 django_bulk_hooks/constants.py,sha256=3x1H1fSUUNo0DZONN7GUVDuySZctTR-jtByBHmAIX5w,303
 django_bulk_hooks/context.py,sha256=HVDT73uSzvgrOR6mdXTvsBm3hLOgBU8ant_mB7VlFuM,380
 django_bulk_hooks/decorators.py,sha256=zstmb27dKcOHu3Atg7cauewCTzPvUmq03mzVKJRi56o,7230
-django_bulk_hooks/engine.py,sha256=b1AO8qyl2VMt1CHyefn1Gt1_ARaV80yBZ3mGXsJ9_eA,2021
+django_bulk_hooks/engine.py,sha256=CUcdBvXE6mq8fBhMP_Q5Z5oygJiVVAuCjNTf-X7o2j0,2826
 django_bulk_hooks/enums.py,sha256=Zo8_tJzuzZ2IKfVc7gZ-0tWPT8q1QhqZbAyoh9ZVJbs,381
 django_bulk_hooks/handler.py,sha256=Qpg_zT6SsQiTlhduvzXxPdG6uynjyR2fBjj-R6HZiXI,4861
-django_bulk_hooks/manager.py,sha256=-V128ACxPAz82ua4jQRFUkjAKtKW4MN5ppz0bHcv5s4,7138
-django_bulk_hooks/models.py,sha256=CD-v8JAZCOnGAHsAxOrlJz5HiOOXNVhGi7p8n3m4oLk,5423
+django_bulk_hooks/manager.py,sha256=DcVosEA4RS79KSYgw3Z14_a9Sd8CfxNNc5F3eSb8xc0,11459
+django_bulk_hooks/models.py,sha256=9KvWkmrR0wbTHN6r7-FrSSO9ViS83NvG7iXLBw_iDZs,4793
 django_bulk_hooks/queryset.py,sha256=7lLqhZ-XOYsZ1I3Loxi4Nhz79M8HlTYE413AW8nyeDI,1330
 django_bulk_hooks/registry.py,sha256=Vh78exKYcdZhM27120kQm-iXGOjd_kf9ZUYBZ8eQ2V0,683
-django_bulk_hooks-0.1.85.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.1.85.dist-info/METADATA,sha256=JJ0uZaiHpf5An0kqNQySULj4hSSpn0JHEppz-xUwnMg,9051
-django_bulk_hooks-0.1.85.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.1.85.dist-info/RECORD,,
+django_bulk_hooks-0.1.87.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.1.87.dist-info/METADATA,sha256=IBHIfxBDMFhmfN91ste-FLYdovL_YOP-obSLKTVSs24,9051
+django_bulk_hooks-0.1.87.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.1.87.dist-info/RECORD,,