django-bulk-hooks 0.1.273__tar.gz → 0.1.275__tar.gz

{django_bulk_hooks-0.1.273 → django_bulk_hooks-0.1.275}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.273
+Version: 0.1.275
 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
@@ -13,7 +14,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: django (>=5.2.0,<6.0.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.273 → django_bulk_hooks-0.1.275}/django_bulk_hooks/__init__.py

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

{django_bulk_hooks-0.1.273 → django_bulk_hooks-0.1.275}/django_bulk_hooks/handler.py

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

{django_bulk_hooks-0.1.273 → django_bulk_hooks-0.1.275}/django_bulk_hooks/queryset.py

@@ -486,11 +486,14 @@ class HookQuerySetMixin:
         passed through to the correct logic. For MTI, only a subset of options may be supported.
         """
         model_cls, ctx, originals = self._setup_bulk_operation(
-            objs, "bulk_create", require_pks=False,
-            bypass_hooks=bypass_hooks, bypass_validation=bypass_validation,
+            objs,
+            "bulk_create",
+            require_pks=False,
+            bypass_hooks=bypass_hooks,
+            bypass_validation=bypass_validation,
             update_conflicts=update_conflicts,
             unique_fields=unique_fields,
-            update_fields=update_fields
+            update_fields=update_fields,
         )
 
         # When you bulk insert you don't get the primary keys back (if it's an
@@ -524,9 +527,7 @@ class HookQuerySetMixin:
                 existing_records = []
                 new_records = []
 
-                # Store the records for AFTER hooks to avoid duplicate queries
-                ctx.upsert_existing_records = existing_records
-                ctx.upsert_new_records = new_records
+                # We'll store the records for AFTER hooks after classification is complete
 
                 # Build a filter to check which records already exist
                 unique_values = []
@@ -535,10 +536,12 @@ class HookQuerySetMixin:
                     query_fields = {}  # Track which database field to use for each unique field
                     for field_name in unique_fields:
                         # First check for _id field (more reliable for ForeignKeys)
-                        if hasattr(obj, field_name + '_id'):
+                        if hasattr(obj, field_name + "_id"):
                             # Handle ForeignKey fields where _id suffix is used
-                            unique_value[field_name] = getattr(obj, field_name + '_id')
-                            query_fields[field_name] = field_name + '_id'  # Use _id field for query
+                            unique_value[field_name] = getattr(obj, field_name + "_id")
+                            query_fields[field_name] = (
+                                field_name + "_id"
+                            )  # Use _id field for query
                         elif hasattr(obj, field_name):
                             unique_value[field_name] = getattr(obj, field_name)
                             query_fields[field_name] = field_name
@@ -558,8 +561,12 @@ class HookQuerySetMixin:
                             filter_kwargs[db_field_name] = value
                         existing_filters |= Q(**filter_kwargs)
 
-                    logger.debug(f"DEBUG: Existence check query filters: {existing_filters}")
-                    logger.debug(f"DEBUG: Unique fields for values_list: {unique_fields}")
+                    logger.debug(
+                        f"DEBUG: Existence check query filters: {existing_filters}"
+                    )
+                    logger.debug(
+                        f"DEBUG: Unique fields for values_list: {unique_fields}"
+                    )
 
                     # Get all existing records in one query and create a lookup set
                     # We need to use the original unique_fields for values_list to maintain consistency
@@ -571,41 +578,76 @@ class HookQuerySetMixin:
                     raw_existing = list(existing_query.values_list(*unique_fields))
                     logger.debug(f"DEBUG: Raw existing records from DB: {raw_existing}")
 
-                    existing_records_found = []
+                    # Convert database values to match object types for comparison
+                    # This handles cases where object values are strings but DB values are integers
+                    existing_records_lookup = set()
                     for existing_record in raw_existing:
-                        # Convert tuple to a hashable key for lookup
-                        existing_records_lookup.add(existing_record)
-                        existing_records_found.append(existing_record)
+                        # Convert each value in the tuple to match the type from object extraction
+                        converted_record = []
+                        for i, field_name in enumerate(unique_fields):
+                            db_value = existing_record[i]
+                            # Check if this field uses _id suffix in the query
+                            query_field_name = query_fields[field_name]
+                            if query_field_name.endswith("_id"):
+                                # Convert to string to match how we extract from objects
+                                converted_record.append(str(db_value))
+                            else:
+                                converted_record.append(db_value)
+                        converted_tuple = tuple(converted_record)
+                        existing_records_lookup.add(converted_tuple)
 
-                    logger.debug(f"DEBUG: Found {len(existing_records_found)} existing records: {existing_records_found}")
-                    logger.debug(f"DEBUG: Existing records lookup set: {existing_records_lookup}")
+                    logger.debug(
+                        f"DEBUG: Found {len(raw_existing)} existing records from DB"
+                    )
+                    logger.debug(
+                        f"DEBUG: Existing records lookup set: {existing_records_lookup}"
+                    )
 
                     # Separate records based on whether they already exist
                     for obj in objs:
                         obj_unique_value = {}
                         for field_name in unique_fields:
                             # First check for _id field (more reliable for ForeignKeys)
-                            if hasattr(obj, field_name + '_id'):
+                            if hasattr(obj, field_name + "_id"):
                                 # Handle ForeignKey fields where _id suffix is used
-                                obj_unique_value[field_name] = getattr(obj, field_name + '_id')
+                                obj_unique_value[field_name] = getattr(
+                                    obj, field_name + "_id"
+                                )
                             elif hasattr(obj, field_name):
                                 obj_unique_value[field_name] = getattr(obj, field_name)
 
                         # Check if this record already exists using our bulk lookup
                         if obj_unique_value:
                             # Convert object values to tuple for comparison with existing records
-                            obj_unique_tuple = tuple(
-                                obj_unique_value[field_name]
-                                for field_name in unique_fields
+                            # Apply the same type conversion as we did for database values
+                            obj_unique_tuple = []
+                            for field_name in unique_fields:
+                                value = obj_unique_value[field_name]
+                                # Check if this field uses _id suffix in the query
+                                query_field_name = query_fields[field_name]
+                                if query_field_name.endswith("_id"):
+                                    # Convert to string to match how we convert DB values
+                                    obj_unique_tuple.append(str(value))
+                                else:
+                                    obj_unique_tuple.append(value)
+                            obj_unique_tuple = tuple(obj_unique_tuple)
+
+                            logger.debug(
+                                f"DEBUG: Object unique tuple: {obj_unique_tuple}"
+                            )
+                            logger.debug(
+                                f"DEBUG: Object unique value: {obj_unique_value}"
                             )
-                            logger.debug(f"DEBUG: Object unique tuple: {obj_unique_tuple}")
-                            logger.debug(f"DEBUG: Object unique value: {obj_unique_value}")
                             if obj_unique_tuple in existing_records_lookup:
                                 existing_records.append(obj)
-                                logger.debug(f"DEBUG: Found existing record for tuple: {obj_unique_tuple}")
+                                logger.debug(
+                                    f"DEBUG: Found existing record for tuple: {obj_unique_tuple}"
+                                )
                             else:
                                 new_records.append(obj)
-                                logger.debug(f"DEBUG: No existing record found for tuple: {obj_unique_tuple}")
+                                logger.debug(
+                                    f"DEBUG: No existing record found for tuple: {obj_unique_tuple}"
+                                )
                         else:
                             # If we can't determine uniqueness, treat as new
                             new_records.append(obj)
@@ -613,6 +655,10 @@ class HookQuerySetMixin:
                     # If no unique fields, treat all as new
                     new_records = objs
 
+                # Store the classified records for AFTER hooks to avoid duplicate queries
+                ctx.upsert_existing_records = existing_records
+                ctx.upsert_new_records = new_records
+
                 # Handle auto_now fields intelligently for upsert operations
                 # Only set auto_now fields on records that will actually be created
                 self._handle_auto_now_fields(new_records, add=True)
@@ -980,7 +1026,9 @@ class HookQuerySetMixin:
 
         changed_fields = self._detect_changed_fields(objs)
         is_mti = self._is_multi_table_inheritance()
-        hook_context, originals = self._init_hook_context(bypass_hooks, objs, "bulk_update")
+        hook_context, originals = self._init_hook_context(
+            bypass_hooks, objs, "bulk_update"
+        )
 
         fields_set, auto_now_fields, custom_update_fields = self._prepare_update_fields(
             changed_fields
@@ -1163,7 +1211,9 @@ class HookQuerySetMixin:
             operation_name,
         )
 
-    def _init_hook_context(self, bypass_hooks: bool, objs, operation_name="bulk_update"):
+    def _init_hook_context(
+        self, bypass_hooks: bool, objs, operation_name="bulk_update"
+    ):
         """
         Initialize the hook context for bulk operations.
 
@@ -1180,7 +1230,9 @@ class HookQuerySetMixin:
         model_cls = self.model
 
         if bypass_hooks:
-            logger.debug("%s: hooks bypassed for %s", operation_name, model_cls.__name__)
+            logger.debug(
+                "%s: hooks bypassed for %s", operation_name, model_cls.__name__
+            )
             ctx = HookContext(model_cls, bypass_hooks=True)
         else:
             logger.debug("%s: hooks enabled for %s", operation_name, model_cls.__name__)
@@ -1299,7 +1351,18 @@ class HookQuerySetMixin:
 
         return list(set(handled_fields))  # Remove duplicates
 
-    def _execute_hooks_with_operation(self, operation_func, validate_hook, before_hook, after_hook, objs, originals=None, ctx=None, bypass_hooks=False, bypass_validation=False):
+    def _execute_hooks_with_operation(
+        self,
+        operation_func,
+        validate_hook,
+        before_hook,
+        after_hook,
+        objs,
+        originals=None,
+        ctx=None,
+        bypass_hooks=False,
+        bypass_validation=False,
+    ):
         """
         Execute the complete hook lifecycle around a database operation.
 
@@ -1359,10 +1422,21 @@ class HookQuerySetMixin:
             param_str = f", {', '.join(param_parts)}"
 
         # Use both print and logger for consistency with existing patterns
-        print(f"DEBUG: {operation_name} called for {model_cls.__name__} with {len(objs)} objects{param_str}")
-        logger.debug(f"{operation_name} called for {model_cls.__name__} with {len(objs)} objects{param_str}")
+        print(
+            f"DEBUG: {operation_name} called for {model_cls.__name__} with {len(objs)} objects{param_str}"
+        )
+        logger.debug(
+            f"{operation_name} called for {model_cls.__name__} with {len(objs)} objects{param_str}"
+        )
 
-    def _execute_delete_hooks_with_operation(self, operation_func, objs, ctx=None, bypass_hooks=False, bypass_validation=False):
+    def _execute_delete_hooks_with_operation(
+        self,
+        operation_func,
+        objs,
+        ctx=None,
+        bypass_hooks=False,
+        bypass_validation=False,
+    ):
         """
         Execute hooks for delete operations with special field caching logic.
 
@@ -1414,7 +1488,15 @@ class HookQuerySetMixin:
 
         return result
 
-    def _setup_bulk_operation(self, objs, operation_name, require_pks=False, bypass_hooks=False, bypass_validation=False, **log_kwargs):
+    def _setup_bulk_operation(
+        self,
+        objs,
+        operation_name,
+        require_pks=False,
+        bypass_hooks=False,
+        bypass_validation=False,
+        **log_kwargs,
+    ):
         """
         Common setup logic for bulk operations.
 
@@ -1433,7 +1515,9 @@ class HookQuerySetMixin:
         self._log_bulk_operation_start(operation_name, objs, **log_kwargs)
 
         # Validate objects
-        self._validate_objects(objs, require_pks=require_pks, operation_name=operation_name)
+        self._validate_objects(
+            objs, require_pks=require_pks, operation_name=operation_name
+        )
 
         # Initialize hook context
         ctx, originals = self._init_hook_context(bypass_hooks, objs, operation_name)
@@ -1974,8 +2058,11 @@ class HookQuerySetMixin:
             return 0
 
         model_cls, ctx, _ = self._setup_bulk_operation(
-            objs, "bulk_delete", require_pks=True,
-            bypass_hooks=bypass_hooks, bypass_validation=bypass_validation
+            objs,
+            "bulk_delete",
+            require_pks=True,
+            bypass_hooks=bypass_hooks,
+            bypass_validation=bypass_validation,
         )
 
         # Execute the database operation with hooks
@@ -1988,8 +2075,11 @@ class HookQuerySetMixin:
                 return 0
 
         result = self._execute_delete_hooks_with_operation(
-            delete_operation, objs, ctx=ctx,
-            bypass_hooks=bypass_hooks, bypass_validation=bypass_validation
+            delete_operation,
+            objs,
+            ctx=ctx,
+            bypass_hooks=bypass_hooks,
+            bypass_validation=bypass_validation,
         )
 
         return result

{django_bulk_hooks-0.1.273 → django_bulk_hooks-0.1.275}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.273"
+version = "0.1.275"
 description = "Hook-style hooks for Django bulk operations like bulk_create and bulk_update."
 authors = ["Konrad Beck <konrad.beck@merchantcapital.co.za>"]
 readme = "README.md"