GeneralManager 0.80.8__tar.gz → 0.81.0__tar.gz

{generalmanager-0.80.8/src/GeneralManager.egg-info → generalmanager-0.81.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.80.8
+Version: 0.81.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.80.8 → generalmanager-0.81.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.80.8"
+version = "0.81.0"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.80.8 → generalmanager-0.81.0/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.80.8
+Version: 0.81.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/GeneralManager.egg-info/SOURCES.txt

@@ -68,6 +68,7 @@ src/general_manager/bucket/projection.py
 src/general_manager/bucket/request_bucket.py
 src/general_manager/cache/__init__.py
 src/general_manager/cache/_dependency_graph.py
+src/general_manager/cache/batch_refresh.py
 src/general_manager/cache/cache_decorator.py
 src/general_manager/cache/cache_tracker.py
 src/general_manager/cache/data_change_context.py
@@ -181,6 +182,8 @@ src/general_manager/interface/capabilities/existing_model/_compat.py
 src/general_manager/interface/capabilities/existing_model/resolution.py
 src/general_manager/interface/capabilities/orm/__init__.py
 src/general_manager/interface/capabilities/orm/_compat.py
+src/general_manager/interface/capabilities/orm/bulk.py
+src/general_manager/interface/capabilities/orm/create_many.py
 src/general_manager/interface/capabilities/orm/history.py
 src/general_manager/interface/capabilities/orm/lifecycle.py
 src/general_manager/interface/capabilities/orm/mutations.py
@@ -227,6 +230,7 @@ src/general_manager/management/commands/shell.py
 src/general_manager/management/commands/workflow_drain_outbox.py
 src/general_manager/management/commands/workflow_replay_dead_letters.py
 src/general_manager/manager/__init__.py
+src/general_manager/manager/bulk_create.py
 src/general_manager/manager/general_manager.py
 src/general_manager/manager/group_manager.py
 src/general_manager/manager/input.py

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/_types/cache.py

@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 __all__ = [
+    "BatchRefreshDisconnect",
     "CacheBackend",
     "CalculationRunContext",
     "Dependency",
     "DependencyTracker",
     "cached",
+    "connect_batch_refresh_receiver",
     "current_calculation_run_context",
     "ensure_calculation_run_context",
     "invalidate_cache_key",
@@ -17,11 +19,13 @@ __all__ = [
     "serialize_dependency_identifier",
 ]
 
+from general_manager.cache.batch_refresh import BatchRefreshDisconnect
 from general_manager.cache.cache_decorator import CacheBackend
 from general_manager.cache.run_context import CalculationRunContext
 from general_manager.cache.dependency_index import Dependency
 from general_manager.cache.cache_tracker import DependencyTracker
 from general_manager.cache.cache_decorator import cached
+from general_manager.cache.batch_refresh import connect_batch_refresh_receiver
 from general_manager.cache.run_context import current_calculation_run_context
 from general_manager.cache.run_context import ensure_calculation_run_context
 from general_manager.cache.dependency_index import invalidate_cache_key

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/_types/general_manager.py

@@ -4,7 +4,14 @@ from __future__ import annotations
 
 __all__ = [
     "AdditiveManagerPermission",
+    "BatchRefreshDisconnect",
+    "BulkCreateEligibility",
     "CalculationInterface",
+    "CreateManyBatchResult",
+    "CreateManyError",
+    "CreateManyInvalidBatchSizeError",
+    "CreateManyPostCommitError",
+    "CreateManyUnsupportedError",
     "DatabaseInterface",
     "ExcelCharField",
     "ExcelDecimalField",
@@ -30,8 +37,10 @@ __all__ = [
     "SearchConfigSpec",
     "SearchIndexer",
     "SearchInvalidationRule",
+    "bulk_create_eligibility",
     "configure_search_backend",
     "configure_search_backend_from_settings",
+    "connect_batch_refresh_receiver",
     "get_logger",
     "get_search_backend",
     "graph_ql_mutation",
@@ -45,7 +54,14 @@ __all__ = [
 from general_manager.permission.manager_based_permission import (
     AdditiveManagerPermission,
 )
+from general_manager.cache.batch_refresh import BatchRefreshDisconnect
+from general_manager.interface.capabilities.orm.bulk import BulkCreateEligibility
 from general_manager.interface.interfaces.calculation import CalculationInterface
+from general_manager.manager.bulk_create import CreateManyBatchResult
+from general_manager.manager.bulk_create import CreateManyError
+from general_manager.manager.bulk_create import CreateManyInvalidBatchSizeError
+from general_manager.manager.bulk_create import CreateManyPostCommitError
+from general_manager.manager.bulk_create import CreateManyUnsupportedError
 from general_manager.interface.interfaces.database import DatabaseInterface
 from general_manager.interface.excel import ExcelCharField
 from general_manager.interface.excel import ExcelDecimalField
@@ -73,10 +89,12 @@ from general_manager.search.config import SearchConfigProtocol
 from general_manager.search.config import SearchConfigSpec
 from general_manager.search.indexer import SearchIndexer
 from general_manager.search.config import SearchInvalidationRule
+from general_manager.interface.capabilities.orm.bulk import bulk_create_eligibility
 from general_manager.search.backend_registry import configure_search_backend
 from general_manager.search.backend_registry import (
     configure_search_backend_from_settings,
 )
+from general_manager.cache.batch_refresh import connect_batch_refresh_receiver
 from general_manager.logging import get_logger
 from general_manager.search.backend_registry import get_search_backend
 from general_manager.api.mutation import graph_ql_mutation

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/_types/manager.py

@@ -3,6 +3,11 @@
 from __future__ import annotations
 
 __all__ = [
+    "CreateManyBatchResult",
+    "CreateManyError",
+    "CreateManyInvalidBatchSizeError",
+    "CreateManyPostCommitError",
+    "CreateManyUnsupportedError",
     "DateRangeDomain",
     "GeneralManager",
     "GeneralManagerMeta",
@@ -15,6 +20,11 @@ __all__ = [
     "graph_ql_property",
 ]
 
+from general_manager.manager.bulk_create import CreateManyBatchResult
+from general_manager.manager.bulk_create import CreateManyError
+from general_manager.manager.bulk_create import CreateManyInvalidBatchSizeError
+from general_manager.manager.bulk_create import CreateManyPostCommitError
+from general_manager.manager.bulk_create import CreateManyUnsupportedError
 from general_manager.manager.input import DateRangeDomain
 from general_manager.manager.general_manager import GeneralManager
 from general_manager.manager.meta import GeneralManagerMeta

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/api/graphql.py

@@ -2271,12 +2271,22 @@ class GraphQL:
                 if identification is not None
                 else event_instance.identification
             )
-            transaction.on_commit(
-                lambda: cls._publish_data_change(
+            from general_manager.manager.bulk_create import current_create_many_batch
+
+            batch = current_create_many_batch(database_alias)
+
+            def callback() -> None:
+                cls._publish_data_change(
                     manager_class,
                     action,
                     event_identification,
-                ),
+                )
+
+            if batch is not None and batch.manager_class is manager_class:
+                batch.notification_callbacks.append(callback)
+                return
+            transaction.on_commit(
+                callback,
                 using=database_alias,
             )
         finally:

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/api/remote_invalidation.py

@@ -214,12 +214,22 @@ def emit_remote_invalidation(
         captured_identification = (
             deepcopy(event_identification) if event_identification is not None else None
         )
-        transaction.on_commit(
-            lambda: _publish_remote_invalidation(
+        from general_manager.manager.bulk_create import current_create_many_batch
+
+        batch = current_create_many_batch(database_alias)
+
+        def callback() -> None:
+            _publish_remote_invalidation(
                 config,
                 action,
                 captured_identification,
-            ),
+            )
+
+        if batch is not None and batch.manager_class is sender:
+            batch.notification_callbacks.append(callback)
+            return
+        transaction.on_commit(
+            callback,
             using=database_alias,
         )
     finally:

generalmanager-0.81.0/src/general_manager/cache/batch_refresh.py

@@ -0,0 +1,139 @@
+"""Opt-in refresh callbacks that understand ``GeneralManager.create_many``.
+
+The registration point is intentionally separate from the private data-change
+signals.  Applications may register a cache or projection refresh without
+having to disconnect framework receivers in order to make an import efficient.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from copy import deepcopy
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import TYPE_CHECKING, cast
+from weakref import WeakSet
+
+from django.db import transaction
+
+from general_manager.cache.signals import post_data_change
+
+if TYPE_CHECKING:  # pragma: no cover
+    from general_manager.manager.bulk_create import CreateManyBatchContext
+    from general_manager.manager.general_manager import GeneralManager
+
+
+BatchRefreshCallback = Callable[
+    [type["GeneralManager"], tuple[Mapping[str, object], ...], str, str], None
+]
+_registered_receivers: WeakSet[Callable[..., None]] = WeakSet()
+
+
+@dataclass(frozen=True)
+class BatchRefreshDisconnect:
+    """A small, idempotent handle returned by batch-refresh registration."""
+
+    receiver: Callable[..., None]
+
+    def disconnect(self) -> None:
+        """Remove this callback without affecting unrelated signal receivers."""
+        post_data_change.disconnect(self.receiver)
+
+    def __call__(self) -> None:
+        self.disconnect()
+
+
+def connect_batch_refresh_receiver(
+    callback: BatchRefreshCallback,
+    *,
+    on_commit: bool = False,
+) -> BatchRefreshDisconnect:
+    """Register a cache refresh callback for ordinary and batched mutations.
+
+    Callbacks run inside the mutation transaction by default.  Passing
+    ``on_commit=True`` defers ordinary changes and a successfully committed
+    ``create_many`` batch until its transaction is durable.  A bulk SQL batch
+    records all identifiers and invokes a registered callback once; canonical
+    row-by-row batches deliberately retain their ordinary per-row timing.
+    Identifications are full, read-only mapping snapshots, including composite
+    keys. Missing identification mappings are rejected instead of losing keys.
+    """
+
+    def receiver(
+        sender: type["GeneralManager"],
+        *,
+        identification: Mapping[str, object] | None = None,
+        instance: object | None = None,
+        action: str | None = None,
+        database_alias: str = "default",
+        **_: object,
+    ) -> None:
+        if action not in {"create", "update", "delete"}:
+            return
+        from general_manager.manager.bulk_create import current_create_many_batch
+
+        batch = current_create_many_batch(database_alias)
+        identification_value = identification
+        if identification_value is None and instance is not None:
+            identification_value = getattr(instance, "identification", None)
+        if not isinstance(identification_value, Mapping):
+            message = "Batch refresh requires an identification mapping."
+            raise TypeError(message)
+        identification_snapshot = MappingProxyType(deepcopy(dict(identification_value)))
+
+        def invoke() -> None:
+            callback(sender, (identification_snapshot,), action, database_alias)
+
+        # The SQL path has already performed the publication barrier and asks
+        # us to aggregate.  Canonical batches keep their legacy receiver timing.
+        if (
+            batch is not None
+            and batch.manager_class is sender
+            and getattr(batch, "bulk_sql_active", False)
+        ):
+            registration = batch.batch_refresh_callbacks.setdefault(
+                id(receiver), (callback, on_commit, action, [])
+            )
+            registration[3].append(identification_snapshot)
+            return
+
+        if on_commit:
+            transaction.on_commit(invoke, using=database_alias)
+        else:
+            invoke()
+
+    post_data_change.connect(receiver, weak=False)
+    _registered_receivers.add(receiver)
+    return BatchRefreshDisconnect(receiver)
+
+
+def flush_batch_refresh_callbacks(context: "CreateManyBatchContext") -> None:
+    """Run registered callbacks once after an eligible SQL create batch."""
+    callbacks = context.batch_refresh_callbacks
+    database_alias = context.database_alias
+    sender = cast(type["GeneralManager"], context.manager_class)
+    for raw_callback, on_commit, action, identifiers in tuple(callbacks.values()):
+        callback = cast(BatchRefreshCallback, raw_callback)
+        frozen_ids = tuple(identifiers)
+
+        def invoke(
+            callback: BatchRefreshCallback = callback,
+            frozen_ids: tuple[Mapping[str, object], ...] = frozen_ids,
+            action: str = action,
+        ) -> None:
+            callback(sender, frozen_ids, action, database_alias)
+
+        if on_commit:
+            transaction.on_commit(invoke, using=database_alias)
+        else:
+            invoke()
+    callbacks.clear()
+
+
+def is_batch_refresh_receiver(receiver: object) -> bool:
+    """Return whether ``receiver`` is one created by this public helper."""
+    try:
+        return receiver in _registered_receivers
+    except TypeError:
+        # Application signal receivers may be callable, unhashable objects.
+        return False

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/cache/dependency_index.py

@@ -1689,6 +1689,11 @@ def generic_cache_invalidation(
         old_relevant_values (dict[str, object]): Mapping of lookup paths (joined by "__") to their values as captured before the change; used to compare old vs. new values for invalidation decisions.
         database_alias (str): Database alias used to attribute invalidation timing.
     """
+    from general_manager.manager.bulk_create import current_create_many_batch
+
+    batch = current_create_many_batch(database_alias)
+    if batch is not None and batch.manager_class is sender and batch.bulk_sql_active:
+        return
     started = perf_counter()
     try:
         invalidated_cache_keys = _invalidate_manager_cache_for_instance_change(

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/cache/signals.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from contextlib import nullcontext
+from contextlib import AbstractContextManager, nullcontext
 from copy import deepcopy
 from functools import wraps
 from time import perf_counter
@@ -101,7 +101,7 @@ def data_change(
     )
 
     @wraps(decorator_source)
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+    def perform_change(*args: P.args, **kwargs: P.kwargs) -> R:
         """
         Emit pre_data_change and post_data_change signals around the wrapped function call.
 
@@ -124,6 +124,12 @@ def data_change(
         )
         from general_manager.cache.run_context import current_calculation_run_context
         from general_manager.interface.orm_interface import OrmInterfaceBase
+        from general_manager.manager.bulk_create import (
+            CreateManyUnsupportedError,
+            current_create_many_batch,
+            enclosing_create_many_batch,
+            validate_create_many_history,
+        )
 
         action = decorator_source.__name__
         if action == "create":
@@ -140,9 +146,29 @@ def data_change(
         database_alias = DEFAULT_DB_ALIAS
         if is_orm_backed:
             database_alias = getattr(interface, "database", None) or DEFAULT_DB_ALIAS
+        batch_envelope = enclosing_create_many_batch()
+        if batch_envelope is not None and (
+            not is_orm_backed or database_alias != batch_envelope.database_alias
+        ):
+            raise CreateManyUnsupportedError.routing()
+        if batch_envelope is not None:
+            validate_create_many_history(getattr(interface, "_model", None))
         change_context: dict[str, object] = {}
         signal_kwargs = {
-            **kwargs,
+            **{
+                key: value
+                for key, value in kwargs.items()
+                if key
+                not in {
+                    "sender",
+                    "signal",
+                    "instance",
+                    "action",
+                    "previous_instance",
+                    "identification",
+                    "old_relevant_values",
+                }
+            },
             "change_context": change_context,
             "database_alias": database_alias,
         }
@@ -159,11 +185,16 @@ def data_change(
             context.clear_bucket_projections()
             context.clear_trusted_orm_managers()
         try:
-            transaction_context = (
-                transaction.atomic(using=database_alias)
-                if is_orm_backed
-                else nullcontext()
-            )
+            transaction_context: AbstractContextManager[None]
+            if not is_orm_backed:
+                transaction_context = nullcontext()
+            elif current_create_many_batch(database_alias) is None:
+                transaction_context = transaction.atomic(using=database_alias)
+            else:
+                transaction_context = transaction.atomic(
+                    using=database_alias,
+                    savepoint=False,
+                )
             caller_in_atomic_block = (
                 _caller_in_atomic_block(database_alias) if is_orm_backed else False
             )
@@ -322,4 +353,11 @@ def data_change(
                 except Exception:
                     logger.exception("GraphQL warm-up requeue failed.")
 
+    @wraps(decorator_source)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        from general_manager.manager.bulk_create import create_many_signal_scope
+
+        with create_many_signal_scope():
+            return perform_change(*args, **kwargs)
+
     return wrapper

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/interface/base_interface.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 from abc import ABC
-from collections.abc import Awaitable, Mapping
+from collections.abc import Awaitable, Iterator, Mapping
 from dataclasses import dataclass
 from functools import wraps
 import inspect
@@ -31,7 +31,11 @@ from general_manager.as_of import (
 )
 from general_manager.utils._args_to_kwargs import args_to_kwargs
 from general_manager.api.property import GraphQLProperty
-from general_manager.interface.capabilities.base import Capability, CapabilityName
+from general_manager.interface.capabilities.base import (
+    Capability,
+    CapabilityName,
+    CreateManyCapability,
+)
 from general_manager.interface.capabilities.configuration import (
     CapabilityConfigEntry,
     InterfaceCapabilityConfig,
@@ -42,6 +46,7 @@ from general_manager.interface.infrastructure.startup_hooks import register_star
 from general_manager.interface.infrastructure.system_checks import register_system_check
 
 if TYPE_CHECKING:
+    from general_manager.manager.bulk_create import CreateManyBatchResult
     from general_manager.manager.input import Input
     from general_manager.manager.general_manager import GeneralManager
     from general_manager.bucket.base_bucket import Bucket
@@ -333,7 +338,7 @@ class InterfaceBase(ABC):
         This method resets per-subclass capability registries and configuration to a clean default, merges configured capability overrides into the class's capability_overrides mapping, and clears the flag that marks configured capabilities as applied. Keyword arguments are forwarded to the superclass implementation.
         """
         super().__init_subclass__(**kwargs)
-        for mutation_name in ("create", "update", "delete"):
+        for mutation_name in ("create", "create_many", "update", "delete"):
             _guard_declared_mutation(cls, mutation_name)
         cls._input_parsing_plan = None
         cls._input_dependency_order = None
@@ -1163,6 +1168,50 @@ class InterfaceBase(ABC):
             observer=observer,
         )
 
+    @classmethod
+    def create_many(
+        cls,
+        records: Iterable[Mapping[str, object]],
+        *,
+        manager_class: type[GeneralManager] | None = None,
+        creator_id: int | None = None,
+        history_comment: str | None = None,
+        ignore_permission: bool = False,
+        batch_size: int = 1000,
+    ) -> Iterator[CreateManyBatchResult]:
+        """Dispatch to an optional backend-owned batch capability.
+
+        Without a callable handler this raises CreateManyUnsupportedError before
+        touching records. The handler owns lazy iteration, atomicity, permission,
+        identity, lifecycle and observability guarantees; see CreateManyCapability.
+        A direct interface call uses its owning manager unless explicitly supplied.
+        """
+        from general_manager.manager.bulk_create import (
+            CreateManyInvalidBatchSizeError,
+            CreateManyUnsupportedError,
+        )
+
+        reject_historical_mutation()
+        if (
+            isinstance(batch_size, bool)
+            or not isinstance(batch_size, int)
+            or batch_size <= 0
+        ):
+            raise CreateManyInvalidBatchSizeError
+        handler = cls.get_capability_handler("create_many")
+        if not callable(getattr(handler, "create_many", None)):
+            raise CreateManyUnsupportedError.missing_capability(cls.__name__)
+        owner = manager_class if manager_class is not None else cls._parent_class
+        return cast(CreateManyCapability, handler).create_many(
+            cls,
+            records,
+            manager_class=owner,
+            creator_id=creator_id,
+            history_comment=history_comment,
+            ignore_permission=ignore_permission,
+            batch_size=batch_size,
+        )
+
     def update(self, *args: object, **kwargs: object) -> object:
         """
         Update the underlying managed record.

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/interface/bundles/database.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from general_manager.interface.capabilities.orm.create_many import (
+    OrmCreateManyCapability,
+)
 from general_manager.interface.capabilities.configuration import (
     CapabilitySet,
     InterfaceCapabilityConfig,
@@ -51,6 +54,7 @@ ORM_WRITABLE_CAPABILITIES: CapabilitySet = CapabilitySet(
         *ORM_PERSISTENCE_CAPABILITIES.entries,
         InterfaceCapabilityConfig(OrmMutationCapability),
         InterfaceCapabilityConfig(OrmCreateCapability),
+        InterfaceCapabilityConfig(OrmCreateManyCapability),
         InterfaceCapabilityConfig(OrmUpdateCapability),
         InterfaceCapabilityConfig(OrmDeleteCapability),
     ),

{generalmanager-0.80.8 → generalmanager-0.81.0}/src/general_manager/interface/capabilities/base.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable, Iterator, Mapping
+
 from typing import ClassVar, Literal, Protocol, TYPE_CHECKING, runtime_checkable
 
 CapabilityName = Literal[
     "read",
     "create",
+    "create_many",
     "update",
     "delete",
     "history",
@@ -37,6 +40,8 @@ Capability names are stable string keys. Interfaces store active names in
 """
 
 if TYPE_CHECKING:  # pragma: no cover
+    from general_manager.manager.general_manager import GeneralManager
+    from general_manager.manager.bulk_create import CreateManyBatchResult
     from general_manager.interface.base_interface import InterfaceBase
 
 
@@ -86,3 +91,33 @@ class Capability(Protocol):
             Exception: Concrete capability implementations define their own
                 teardown errors, which propagate unchanged.
         """
+
+
+class CreateManyCapability(Capability, Protocol):
+    """Optional backend batch contract used by InterfaceBase.create_many.
+
+    A handler validates support before consuming input and returns a lazy,
+    bounded iterator. Each batch is atomic, including required history/outbox
+    writes; permissions and canonical lifecycle/observability must be preserved
+    or an explicitly safe fallback selected. It must recheck historical mutation
+    restrictions when the iterator advances. Failed writes and post-commit
+    effects remain distinct using CreateManyError/CreateManyPostCommitError.
+    Results carry backend-defined opaque ids (including complete mappings),
+    accurate provisional/durable counts and an optional Django database alias.
+    A backend unable to provide this contract must reject before consumption;
+    there is deliberately no row-by-row non-atomic fallback in the dispatcher.
+    """
+
+    def create_many(
+        self,
+        interface_cls: type[InterfaceBase],
+        records: Iterable[Mapping[str, object]],
+        *,
+        manager_class: type[GeneralManager],
+        creator_id: int | None = None,
+        history_comment: str | None = None,
+        ignore_permission: bool = False,
+        batch_size: int = 1000,
+    ) -> Iterator[CreateManyBatchResult]:
+        """Return progress only after a whole batch has successfully persisted."""
+        ...