GeneralManager 0.48.0__tar.gz → 0.49.0__tar.gz

{generalmanager-0.48.0/src/GeneralManager.egg-info → generalmanager-0.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.48.0
+Version: 0.49.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.48.0 → generalmanager-0.49.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.48.0"
+version = "0.49.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.48.0 → generalmanager-0.49.0/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.48.0
+Version: 0.49.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.48.0 → generalmanager-0.49.0}/src/general_manager/cache/cache_decorator.py

@@ -28,6 +28,7 @@ from general_manager.cache.dependency_index import (
 )
 from general_manager.cache.dependency_publish import (
     CachePublishAborted,
+    PendingDependencyCachePublication,
     acquire_compute_lease,
     publish_dependency_cache_entry,
     release_compute_lease,
@@ -232,6 +233,7 @@ def cached(
                     )
                 lease = acquire_compute_lease(key)
 
+            lease_transferred_to_context = False
             try:
                 cached_hit = read_dependency_cache_hit(
                     cache_backend,
@@ -252,29 +254,47 @@ def cached(
                     for entry_key, entry_dependencies in entries:
                         record_fn(entry_key, set(entry_dependencies))
 
-                try:
-                    publish_dependency_cache_entry(
-                        cache_key=key,
-                        result=result,
-                        dependencies=dependencies,
-                        cache_backend=cache_backend,
-                        timeout=timeout,
-                        started_generation=started_generation,
-                        record_many_fn=(
-                            None if record_fn is record_dependencies else record_many
-                        ),
-                    )
-                except CachePublishAborted:
-                    logger.debug(
-                        "dependency cache publish aborted",
-                        context={
-                            "function": func.__qualname__,
-                            "key": key,
-                            "scope": scope,
-                        },
+                publish_context = current_calculation_run_context()
+                if publish_context is not None and record_fn is record_dependencies:
+                    publish_context.buffer_dependency_cache_publication(
+                        PendingDependencyCachePublication(
+                            cache_key=key,
+                            result=result,
+                            dependencies=frozenset(dependencies),
+                            cache_backend=cache_backend,
+                            timeout=timeout,
+                            started_generation=started_generation,
+                            lease=lease,
+                        )
                     )
+                    lease_transferred_to_context = True
+                else:
+                    try:
+                        publish_dependency_cache_entry(
+                            cache_key=key,
+                            result=result,
+                            dependencies=dependencies,
+                            cache_backend=cache_backend,
+                            timeout=timeout,
+                            started_generation=started_generation,
+                            record_many_fn=(
+                                None
+                                if record_fn is record_dependencies
+                                else record_many
+                            ),
+                        )
+                    except CachePublishAborted:
+                        logger.debug(
+                            "dependency cache publish aborted",
+                            context={
+                                "function": func.__qualname__,
+                                "key": key,
+                                "scope": scope,
+                            },
+                        )
             finally:
-                release_compute_lease(lease)
+                if not lease_transferred_to_context:
+                    release_compute_lease(lease)
 
             logger.debug(
                 "cache miss recorded",

{generalmanager-0.48.0 → generalmanager-0.49.0}/src/general_manager/cache/dependency_cache.py

@@ -45,6 +45,16 @@ class DependencyCacheGetManyBackend(DependencyCacheBackend, Protocol):
         ...
 
 
+class DependencyCacheSetManyBackend(DependencyCacheBackend, Protocol):
+    def set_many(
+        self,
+        data: Mapping[str, Any],
+        timeout: int | None = None,
+    ) -> Any:
+        """Store cached values for many keys."""
+        ...
+
+
 def make_dependency_cache_entry(
     value: Any,
     dependencies: Iterable[Dependency],

{generalmanager-0.48.0 → generalmanager-0.49.0}/src/general_manager/cache/dependency_index.py

@@ -124,6 +124,14 @@ def _set_dependency_data_change_count(count: int) -> int:
     return count
 
 
+def _discard_active_context_dependency_cache_state() -> None:
+    from general_manager.cache.run_context import current_calculation_run_context
+
+    context = current_calculation_run_context()
+    if context is not None:
+        context.discard_dependency_cache_state()
+
+
 def begin_dependency_data_change() -> int:
     """
     Mark a data change as active and bump the dependency generation.
@@ -136,9 +144,17 @@ def begin_dependency_data_change() -> int:
         generation = _set_dependency_generation(get_dependency_generation() + 1)
         _set_dependency_data_change_count(_get_dependency_data_change_count() + 1)
         cache.set(DATA_CHANGE_LOCK_KEY, "1", None)
-        return generation
     finally:
         release_lock()
+    try:
+        _discard_active_context_dependency_cache_state()
+    except Exception:
+        try:
+            end_dependency_data_change()
+        except Exception:
+            logger.exception("dependency data-change cleanup rollback failed")
+        raise
+    return generation
 
 
 def end_dependency_data_change() -> None:

{generalmanager-0.48.0 → generalmanager-0.49.0}/src/general_manager/cache/dependency_publish.py

@@ -4,13 +4,15 @@ from __future__ import annotations
 
 import time
 import uuid
+from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Callable, Iterable
+from typing import Any, Callable, Iterable, TypeGuard
 
 from django.core.cache import cache as coordination_cache
 
 from general_manager.cache.dependency_cache import (
     DependencyCacheBackend,
+    DependencyCacheSetManyBackend,
     make_dependency_cache_entry,
     read_dependency_cache_hit,
 )
@@ -39,6 +41,19 @@ class CacheComputeLease:
     token: str
 
 
+@dataclass(frozen=True)
+class PendingDependencyCachePublication:
+    """A dependency-cache miss waiting for guarded publication."""
+
+    cache_key: str
+    result: Any
+    dependencies: frozenset[Dependency]
+    cache_backend: DependencyCacheBackend
+    timeout: int | None
+    started_generation: int
+    lease: CacheComputeLease
+
+
 RecordManyDependenciesFn = Callable[[Iterable[tuple[str, Iterable[Dependency]]]], None]
 
 COMPUTE_LOCK_PREFIX = "dependency_cache_compute_lock"
@@ -111,6 +126,81 @@ def _ensure_publish_current(started_generation: int) -> None:
         raise CachePublishAborted()
 
 
+def _supports_set_many(
+    cache_backend: DependencyCacheBackend,
+) -> TypeGuard[DependencyCacheSetManyBackend]:
+    return callable(getattr(cache_backend, "set_many", None))
+
+
+def _set_dependency_cache_entries(
+    entries: Iterable[PendingDependencyCachePublication],
+) -> None:
+    grouped: dict[
+        tuple[int, int | None],
+        list[PendingDependencyCachePublication],
+    ] = defaultdict(list)
+    for entry in entries:
+        grouped[(id(entry.cache_backend), entry.timeout)].append(entry)
+
+    for group_entries in grouped.values():
+        cache_backend = group_entries[0].cache_backend
+        timeout = group_entries[0].timeout
+        payloads = {
+            entry.cache_key: make_dependency_cache_entry(
+                entry.result,
+                entry.dependencies,
+            )
+            for entry in group_entries
+        }
+        if _supports_set_many(cache_backend):
+            failed_keys = cache_backend.set_many(payloads, timeout) or ()
+            for key in failed_keys:
+                if key in payloads:
+                    cache_backend.set(key, payloads[key], timeout)
+            continue
+        for key, payload in payloads.items():
+            cache_backend.set(key, payload, timeout)
+
+
+def publish_dependency_cache_entries(
+    entries: Iterable[PendingDependencyCachePublication],
+) -> None:
+    """Publish dependency metadata and values for current entries in one batch."""
+    pending_entries = tuple(entries)
+    if not pending_entries:
+        return
+
+    acquire_lock_with_retry("publish_dependency_cache_entries")
+    try:
+        if is_dependency_data_change_active():
+            raise CachePublishAborted()
+
+        current_generation = get_dependency_generation()
+        publishable_entries = tuple(
+            entry
+            for entry in pending_entries
+            if entry.started_generation == current_generation
+        )
+        if not publishable_entries:
+            return
+
+        idx = get_full_index()
+        for entry in publishable_entries:
+            if entry.dependencies:
+                _record_dependencies_locked(
+                    idx,
+                    entry.cache_key,
+                    entry.dependencies,
+                )
+
+        _ensure_publish_current(current_generation)
+        set_full_index(idx)
+        _ensure_publish_current(current_generation)
+        _set_dependency_cache_entries(publishable_entries)
+    finally:
+        release_lock()
+
+
 def publish_dependency_cache_entry(
     *,
     cache_key: str,

{generalmanager-0.48.0 → generalmanager-0.49.0}/src/general_manager/cache/run_context.py

@@ -8,8 +8,13 @@ from contextvars import ContextVar, Token
 from types import TracebackType
 from typing import TYPE_CHECKING, Optional, TypeVar
 
+from general_manager.logging import get_logger
+
 if TYPE_CHECKING:
     from general_manager.cache.dependency_cache import DependencyCacheHit
+    from general_manager.cache.dependency_publish import (
+        PendingDependencyCachePublication,
+    )
 
 K = TypeVar("K", bound=Hashable)
 T = TypeVar("T")
@@ -19,14 +24,27 @@ _active_context: ContextVar["CalculationRunContext | None"] = ContextVar(
     default=None,
 )
 ORM_BUCKET_RESULT_PREFIX = "orm_bucket_result"
+DEFAULT_DEPENDENCY_CACHE_PUBLISH_BATCH_SIZE = 1000
+logger = get_logger("cache.run_context")
 
 
 class CalculationRunContext:
     """Cache calculation work for one request, graph, bulk operation, or task."""
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        *,
+        dependency_cache_publish_batch_size: int = (
+            DEFAULT_DEPENDENCY_CACHE_PUBLISH_BATCH_SIZE
+        ),
+    ) -> None:
         self._values: dict[Hashable, object] = {}
         self._dependency_cache_hits: dict[str, DependencyCacheHit] = {}
+        self._dependency_cache_pending_publications: dict[
+            str,
+            PendingDependencyCachePublication,
+        ] = {}
+        self._dependency_cache_publish_batch_size = dependency_cache_publish_batch_size
         self._token: Token[CalculationRunContext | None] | None = None
 
     def __enter__(self) -> "CalculationRunContext":
@@ -39,11 +57,18 @@ class CalculationRunContext:
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
-        if self._token is not None:
-            _active_context.reset(self._token)
-            self._token = None
-        self._values.clear()
-        self._dependency_cache_hits.clear()
+        try:
+            if exc_type is None:
+                self.flush_dependency_cache_publications()
+            else:
+                self.discard_dependency_cache_publications()
+        finally:
+            if self._token is not None:
+                _active_context.reset(self._token)
+                self._token = None
+            self._values.clear()
+            self._dependency_cache_hits.clear()
+            self._dependency_cache_pending_publications.clear()
 
     def get_or_set(self, key: Hashable, loader: Callable[[], T]) -> T:
         """Return a cached value for key, loading it once per active context."""
@@ -74,6 +99,73 @@ class CalculationRunContext:
         """Return a prefetched dependency-cache hit, or default when absent."""
         return self._dependency_cache_hits.get(key, default)
 
+    def buffer_dependency_cache_publication(
+        self,
+        entry: PendingDependencyCachePublication,
+    ) -> None:
+        """Buffer a dependency-cache miss for guarded batch publication."""
+        from general_manager.cache.dependency_cache import DependencyCacheHit
+        from general_manager.cache.dependency_publish import release_compute_lease
+
+        previous_entry = self._dependency_cache_pending_publications.get(
+            entry.cache_key
+        )
+        if previous_entry is not None and previous_entry.lease != entry.lease:
+            release_compute_lease(previous_entry.lease)
+        self._dependency_cache_pending_publications[entry.cache_key] = entry
+        self._dependency_cache_hits[entry.cache_key] = DependencyCacheHit(
+            value=entry.result,
+            dependencies=entry.dependencies,
+        )
+        if (
+            len(self._dependency_cache_pending_publications)
+            >= self._dependency_cache_publish_batch_size
+        ):
+            self.flush_dependency_cache_publications()
+
+    def flush_dependency_cache_publications(self) -> None:
+        """Publish buffered dependency-cache misses and release their leases."""
+        entries = tuple(self._dependency_cache_pending_publications.values())
+        if not entries:
+            return
+        self._dependency_cache_pending_publications.clear()
+
+        from general_manager.cache.dependency_publish import (
+            CachePublishAborted,
+            publish_dependency_cache_entries,
+            release_compute_lease,
+        )
+
+        try:
+            publish_dependency_cache_entries(entries)
+        except CachePublishAborted:
+            logger.debug(
+                "dependency cache batch publish aborted",
+                context={"entry_count": len(entries)},
+            )
+        finally:
+            for entry in entries:
+                release_compute_lease(entry.lease)
+
+    def discard_dependency_cache_publications(self) -> None:
+        """Drop buffered dependency-cache misses and release their leases."""
+        entries = tuple(self._dependency_cache_pending_publications.values())
+        if not entries:
+            return
+        self._dependency_cache_pending_publications.clear()
+
+        from general_manager.cache.dependency_publish import release_compute_lease
+
+        for entry in entries:
+            release_compute_lease(entry.lease)
+
+    def discard_dependency_cache_state(self) -> None:
+        """Drop dependency-cache hits and buffered publications for this run."""
+        try:
+            self.discard_dependency_cache_publications()
+        finally:
+            self._dependency_cache_hits.clear()
+
     def discard_prefix(self, prefix: tuple[Hashable, ...]) -> None:
         """Discard tuple keys that start with the supplied prefix."""
         for key in list(self._values):