GeneralManager 0.69.0__tar.gz → 0.69.2__tar.gz

{generalmanager-0.69.0/src/GeneralManager.egg-info → generalmanager-0.69.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.69.0
+Version: 0.69.2
 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.69.0 → generalmanager-0.69.2}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.69.0
+Version: 0.69.2
 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.69.0 → generalmanager-0.69.2}/src/general_manager/cache/run_context.py

@@ -6,6 +6,7 @@ from collections import defaultdict
 from collections.abc import Callable, Hashable, Iterable, Mapping
 from contextvars import ContextVar, Token
 from dataclasses import dataclass
+from threading import RLock, get_ident
 from types import TracebackType
 from typing import TYPE_CHECKING, Optional, TypeVar, cast
 
@@ -43,8 +44,10 @@ ORM_BUCKET_EXISTS_PREFIX = "orm_bucket_exists"
 BUCKET_INDEX_PREFIX = "bucket_index"
 TRUSTED_ORM_MANAGER_PREFIX = "trusted_orm_manager"
 DEFAULT_DEPENDENCY_CACHE_PUBLISH_BATCH_SIZE = 1000
+RUN_CONTEXT_TOUCH_BATCH_SIZE = 64
 logger = get_logger("cache.run_context")
 OrmModelRowKey = tuple[Hashable, Hashable | None]
+PendingRunCacheTouch = tuple[RunCacheNamespace, Hashable]
 
 
 @dataclass(frozen=True)
@@ -104,9 +107,18 @@ class CalculationRunContext:
         ] = {}
         self._dependency_cache_publish_batch_size = dependency_cache_publish_batch_size
         self._tokens: list[Token[CalculationRunContext | None]] = []
+        self._run_cache_touch_lock = RLock()
+        self._pending_run_cache_touches: dict[PendingRunCacheTouch, None] = {}
+        self._last_pending_run_cache_touch: PendingRunCacheTouch | None = None
+        self._run_cache_touch_count = 0
+        self._run_cache_touch_thread_id: int | None = None
+        max_bytes = resolve_run_context_cache_max_bytes()
+        self._run_cache_mode_generation = -1
+        self._run_cache_budget_enabled = max_bytes is not None
+        self._run_cache_recency_enabled = False
         run_context_cache_budget.register(
             self,
-            resolve_run_context_cache_max_bytes(),
+            max_bytes,
         )
 
     def _iter_run_cache_entries(
@@ -119,31 +131,54 @@ class CalculationRunContext:
             if key not in self._dependency_cache_pending_publications:
                 yield "dependency_hits", key, hit
 
+    def _set_run_cache_modes(
+        self,
+        budget_enabled: bool,
+        recency_enabled: bool,
+        generation: int,
+    ) -> None:
+        """Refresh owner hints after a generated coordinator transition."""
+        with self._run_cache_touch_lock:
+            if generation < self._run_cache_mode_generation:
+                return
+            self._run_cache_mode_generation = generation
+            self._run_cache_budget_enabled = budget_enabled
+            self._run_cache_recency_enabled = recency_enabled
+            if not budget_enabled or not recency_enabled:
+                self._pending_run_cache_touches.clear()
+                self._last_pending_run_cache_touch = None
+                self._run_cache_touch_count = 0
+
     def _evict_run_cache_entry(
         self,
         namespace: RunCacheNamespace,
         key: Hashable,
     ) -> None:
         """Remove one entry selected by the process-wide coordinator."""
+        self._discard_run_cache_touch((namespace, key))
         if namespace == "values":
             self._values.pop(key, None)
         elif key not in self._dependency_cache_pending_publications:
             self._dependency_cache_hits.pop(cast(str, key), None)
 
     def _store_run_value(self, scoped_key: Hashable, value: object) -> None:
+        self._flush_run_cache_touches()
         self._values[scoped_key] = value
         run_context_cache_budget.track(self, "values", scoped_key, value)
 
     def _remove_run_value(self, scoped_key: Hashable) -> None:
+        self._discard_run_cache_touch(("values", scoped_key))
         if scoped_key in self._values:
             del self._values[scoped_key]
             run_context_cache_budget.remove(self, "values", scoped_key)
 
     def _refresh_run_value(self, scoped_key: Hashable) -> None:
+        self._discard_run_cache_touch(("values", scoped_key))
         try:
             value = self._values[scoped_key]
         except KeyError:
             return
+        self._flush_run_cache_touches()
         run_context_cache_budget.refresh(self, "values", scoped_key, value)
 
     def _store_dependency_cache_hit(
@@ -151,26 +186,132 @@ class CalculationRunContext:
         key: str,
         hit: DependencyCacheHit,
     ) -> None:
+        is_pending_publication = key in self._dependency_cache_pending_publications
+        if not is_pending_publication:
+            self._flush_run_cache_touches()
         self._dependency_cache_hits[key] = hit
-        if key in self._dependency_cache_pending_publications:
+        if is_pending_publication:
+            self._discard_run_cache_touch(("dependency_hits", key))
             run_context_cache_budget.remove(self, "dependency_hits", key)
         else:
             run_context_cache_budget.track(self, "dependency_hits", key, hit)
 
     def _remove_dependency_cache_hit(self, key: str) -> None:
+        self._discard_run_cache_touch(("dependency_hits", key))
         if key in self._dependency_cache_hits:
             del self._dependency_cache_hits[key]
             run_context_cache_budget.remove(self, "dependency_hits", key)
 
     def _refresh_dependency_cache_hit(self, key: str) -> None:
+        self._discard_run_cache_touch(("dependency_hits", key))
         if key in self._dependency_cache_pending_publications:
             return
         try:
             hit = self._dependency_cache_hits[key]
         except KeyError:
             return
+        self._flush_run_cache_touches()
         run_context_cache_budget.refresh(self, "dependency_hits", key, hit)
 
+    def _queue_run_cache_touch(
+        self,
+        namespace: RunCacheNamespace,
+        key: Hashable,
+    ) -> None:
+        pending_key = (namespace, key)
+        with self._run_cache_touch_lock:
+            if (
+                not self._run_cache_budget_enabled
+                or not self._run_cache_recency_enabled
+            ):
+                return
+            if pending_key != self._last_pending_run_cache_touch:
+                self._pending_run_cache_touches.pop(pending_key, None)
+                self._pending_run_cache_touches[pending_key] = None
+                self._last_pending_run_cache_touch = pending_key
+        self._queue_repeated_run_cache_touch(pending_key)
+
+    def _queue_repeated_run_cache_touch(
+        self,
+        pending_key: PendingRunCacheTouch,
+    ) -> bool:
+        touch_immediately = False
+        touches_to_flush: tuple[PendingRunCacheTouch, ...] = ()
+        mode_generation = -1
+        with self._run_cache_touch_lock:
+            if (
+                not self._run_cache_budget_enabled
+                or not self._run_cache_recency_enabled
+            ):
+                return False
+            if self._run_cache_touch_thread_id != get_ident():
+                touch_immediately = True
+                mode_generation = self._run_cache_mode_generation
+            elif pending_key != self._last_pending_run_cache_touch:
+                return False
+            else:
+                count = self._run_cache_touch_count + 1
+                if count < RUN_CONTEXT_TOUCH_BATCH_SIZE:
+                    self._run_cache_touch_count = count
+                    return True
+                touches_to_flush, mode_generation = (
+                    self._take_run_cache_touches_locked()
+                )
+        if touch_immediately:
+            run_context_cache_budget.touch(
+                self,
+                *pending_key,
+                mode_generation=mode_generation,
+            )
+            return True
+        run_context_cache_budget.touch_many(
+            self,
+            touches_to_flush,
+            mode_generation=mode_generation,
+        )
+        return True
+
+    def _touch_run_cache_entry(
+        self,
+        namespace: RunCacheNamespace,
+        key: Hashable,
+    ) -> None:
+        pending_key: PendingRunCacheTouch = (namespace, key)
+        if not self._queue_repeated_run_cache_touch(pending_key):
+            self._queue_run_cache_touch(namespace, key)
+
+    def _discard_run_cache_touch(self, pending_key: PendingRunCacheTouch) -> None:
+        with self._run_cache_touch_lock:
+            self._pending_run_cache_touches.pop(pending_key, None)
+            if pending_key == self._last_pending_run_cache_touch:
+                self._last_pending_run_cache_touch = next(
+                    reversed(self._pending_run_cache_touches),
+                    None,
+                )
+
+    def _take_run_cache_touches_locked(
+        self,
+    ) -> tuple[tuple[PendingRunCacheTouch, ...], int]:
+        touches = tuple(self._pending_run_cache_touches)
+        mode_generation = self._run_cache_mode_generation
+        self._pending_run_cache_touches.clear()
+        self._last_pending_run_cache_touch = None
+        self._run_cache_touch_count = 0
+        return touches, mode_generation
+
+    def _flush_run_cache_touches(self) -> None:
+        with self._run_cache_touch_lock:
+            if not self._pending_run_cache_touches:
+                self._last_pending_run_cache_touch = None
+                self._run_cache_touch_count = 0
+                return
+            touches, mode_generation = self._take_run_cache_touches_locked()
+        run_context_cache_budget.touch_many(
+            self,
+            touches,
+            mode_generation=mode_generation,
+        )
+
     @staticmethod
     def _scoped_key(key: Hashable) -> Hashable:
         """Namespace a run value by the active historical snapshot."""
@@ -182,9 +323,17 @@ class CalculationRunContext:
     def __enter__(self) -> "CalculationRunContext":
         """Activate this context and return it for the `with` block."""
         if not self._tokens:
+            max_bytes = resolve_run_context_cache_max_bytes()
+            with self._run_cache_touch_lock:
+                self._pending_run_cache_touches.clear()
+                self._last_pending_run_cache_touch = None
+                self._run_cache_touch_count = 0
+                self._run_cache_touch_thread_id = get_ident()
+                self._run_cache_budget_enabled = max_bytes is not None
+                self._run_cache_recency_enabled = False
             run_context_cache_budget.register(
                 self,
-                resolve_run_context_cache_max_bytes(),
+                max_bytes,
             )
         self._tokens.append(_active_context.set(self))
         return self
@@ -219,6 +368,12 @@ class CalculationRunContext:
 
         token = self._tokens.pop()
         is_outermost_exit = not self._tokens
+        if is_outermost_exit:
+            with self._run_cache_touch_lock:
+                self._pending_run_cache_touches.clear()
+                self._last_pending_run_cache_touch = None
+                self._run_cache_touch_count = 0
+                self._run_cache_touch_thread_id = None
         try:
             if is_outermost_exit:
                 if exc_type is None:
@@ -253,7 +408,8 @@ class CalculationRunContext:
             value = loader()
             self._store_run_value(scoped_key, value)
             return value
-        run_context_cache_budget.touch(self, "values", scoped_key)
+        if self._run_cache_recency_enabled:
+            self._touch_run_cache_entry("values", scoped_key)
         return cast(T, value)
 
     def get(self, key: Hashable, default: object = None) -> object:
@@ -263,7 +419,8 @@ class CalculationRunContext:
             value = self._values[scoped_key]
         except KeyError:
             return default
-        run_context_cache_budget.touch(self, "values", scoped_key)
+        if self._run_cache_recency_enabled:
+            self._touch_run_cache_entry("values", scoped_key)
         return value
 
     def set(self, key: Hashable, value: object) -> None:
@@ -294,8 +451,11 @@ class CalculationRunContext:
             hit = self._dependency_cache_hits[key]
         except KeyError:
             return default
-        if key not in self._dependency_cache_pending_publications:
-            run_context_cache_budget.touch(self, "dependency_hits", key)
+        if (
+            self._run_cache_recency_enabled
+            and key not in self._dependency_cache_pending_publications
+        ):
+            self._touch_run_cache_entry("dependency_hits", key)
         return hit
 
     def buffer_dependency_cache_publication(
@@ -718,7 +878,8 @@ class CalculationRunContext:
         scoped_key = self._scoped_key(key)
         if scoped_key not in self._values:
             return False
-        run_context_cache_budget.touch(self, "values", scoped_key)
+        if self._run_cache_recency_enabled:
+            self._touch_run_cache_entry("values", scoped_key)
         return True
 
     def __contains__(self, key: Hashable) -> bool: