GeneralManager 0.46.0__tar.gz → 0.46.1__tar.gz

{generalmanager-0.46.0/src/GeneralManager.egg-info → generalmanager-0.46.1}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.46.0
+Version: 0.46.1
 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.46.0 → generalmanager-0.46.1}/src/GeneralManager.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ src/general_manager/bucket/request_bucket.py
 src/general_manager/cache/__init__.py
 src/general_manager/cache/cache_decorator.py
 src/general_manager/cache/cache_tracker.py
+src/general_manager/cache/dependency_cache.py
 src/general_manager/cache/dependency_index.py
 src/general_manager/cache/dependency_publish.py
 src/general_manager/cache/model_dependency_collector.py

{generalmanager-0.46.0 → generalmanager-0.46.1}/src/general_manager/cache/cache_decorator.py

@@ -16,6 +16,11 @@ from typing import (
 from django.core.cache import cache as django_cache
 
 from general_manager.cache.cache_tracker import DependencyTracker
+from general_manager.cache.dependency_cache import (
+    DependencyCacheHit,
+    read_dependency_cache_hit,
+    replay_dependency_cache_hit,
+)
 from general_manager.cache.dependency_index import (
     Dependency,
     get_dependency_generation,
@@ -26,7 +31,7 @@ from general_manager.cache.dependency_publish import (
     acquire_compute_lease,
     publish_dependency_cache_entry,
     release_compute_lease,
-    wait_for_cached_dependency_value,
+    wait_for_cached_dependency_hit,
 )
 from general_manager.cache.run_context import ensure_calculation_run_context
 from general_manager.cache.model_dependency_collector import ModelDependencyCollector
@@ -179,52 +184,48 @@ def cached(
                 )
                 return result
 
-            deps_key = f"{key}:deps"
-
-            def track_cached_dependencies() -> None:
-                cached_deps = cache_backend.get(deps_key)
-                if cached_deps:
-                    for class_name, operation, identifier in cached_deps:
-                        DependencyTracker.track(class_name, operation, identifier)
-
-            cached_result = cache_backend.get(key, _SENTINEL)
-            if cached_result is not _SENTINEL:
-                track_cached_dependencies()
+            def return_cached_hit(hit: DependencyCacheHit, message: str) -> object:
+                replay_dependency_cache_hit(hit)
                 logger.debug(
-                    "cache hit",
+                    message,
                     context={
                         "function": func.__qualname__,
                         "key": key,
                         "scope": scope,
                     },
                 )
-                return cached_result
+                return hit.value
+
+            cached_hit = read_dependency_cache_hit(
+                cache_backend,
+                key,
+                sentinel=_SENTINEL,
+            )
+            if cached_hit is not _SENTINEL:
+                return return_cached_hit(cached_hit, "cache hit")
 
             lease = acquire_compute_lease(key)
             while lease is None:
-                cached_result = wait_for_cached_dependency_value(
+                cached_hit = wait_for_cached_dependency_hit(
                     cache_backend,
                     key,
                     sentinel=_SENTINEL,
                 )
-                if cached_result is not _SENTINEL:
-                    track_cached_dependencies()
-                    logger.debug(
+                if cached_hit is not _SENTINEL:
+                    return return_cached_hit(
+                        cached_hit,
                         "cache hit after waiting for dependency publish",
-                        context={
-                            "function": func.__qualname__,
-                            "key": key,
-                            "scope": scope,
-                        },
                     )
-                    return cached_result
                 lease = acquire_compute_lease(key)
 
             try:
-                cached_result = cache_backend.get(key, _SENTINEL)
-                if cached_result is not _SENTINEL:
-                    track_cached_dependencies()
-                    return cached_result
+                cached_hit = read_dependency_cache_hit(
+                    cache_backend,
+                    key,
+                    sentinel=_SENTINEL,
+                )
+                if cached_hit is not _SENTINEL:
+                    return return_cached_hit(cached_hit, "cache hit")
 
                 started_generation = get_dependency_generation()
                 with DependencyTracker() as dependencies:
@@ -240,7 +241,6 @@ def cached(
                 try:
                     publish_dependency_cache_entry(
                         cache_key=key,
-                        deps_key=deps_key,
                         result=result,
                         dependencies=dependencies,
                         cache_backend=cache_backend,

generalmanager-0.46.1/src/general_manager/cache/dependency_cache.py

@@ -0,0 +1,154 @@
+"""Internal helpers for dependency-scoped cache entry reads."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable, Mapping, Protocol, TypeGuard
+
+from general_manager.cache.cache_tracker import DependencyTracker
+from general_manager.cache.dependency_index import Dependency
+
+DEPENDENCY_CACHE_ENTRY_VERSION = 1
+_MISSING = object()
+
+
+@dataclass(frozen=True, slots=True)
+class DependencyCacheEntry:
+    """Persisted dependency-cache payload stored at the main cache key."""
+
+    version: int
+    value: Any
+    dependencies: frozenset[Dependency]
+
+
+@dataclass(frozen=True, slots=True)
+class DependencyCacheHit:
+    """In-memory representation of a dependency-cache hit."""
+
+    value: Any
+    dependencies: frozenset[Dependency]
+
+
+class DependencyCacheBackend(Protocol):
+    def get(self, key: str, default: Any = None) -> Any:
+        """Return a cached value or *default* when absent."""
+        ...
+
+    def set(self, key: str, value: Any, timeout: int | None = None) -> None:
+        """Store a cached value."""
+        ...
+
+
+class DependencyCacheGetManyBackend(DependencyCacheBackend, Protocol):
+    def get_many(self, keys: Iterable[str]) -> Mapping[str, Any]:
+        """Return cached values for all found keys."""
+        ...
+
+
+def make_dependency_cache_entry(
+    value: Any,
+    dependencies: Iterable[Dependency],
+) -> DependencyCacheEntry:
+    """Build the current persisted dependency-cache payload."""
+    return DependencyCacheEntry(
+        version=DEPENDENCY_CACHE_ENTRY_VERSION,
+        value=value,
+        dependencies=frozenset(dependencies),
+    )
+
+
+def read_dependency_cache_hit(
+    cache_backend: DependencyCacheBackend,
+    cache_key: str,
+    *,
+    sentinel: Any = _MISSING,
+) -> DependencyCacheHit | Any:
+    """Read one dependency-cache entry, including legacy split entries."""
+    payload = cache_backend.get(cache_key, sentinel)
+    if payload is sentinel:
+        return sentinel
+    combined_hit = _combined_payload_to_hit(payload)
+    if combined_hit is _MISSING:
+        return sentinel
+    if combined_hit is not None:
+        return combined_hit
+    dependency_payload = cache_backend.get(_legacy_deps_key(cache_key), ())
+    return DependencyCacheHit(
+        value=payload,
+        dependencies=frozenset(dependency_payload or ()),
+    )
+
+
+def read_many_dependency_cache_hits(
+    cache_backend: DependencyCacheBackend,
+    cache_keys: Iterable[str],
+) -> dict[str, DependencyCacheHit]:
+    """Bulk-read dependency-cache hits for known keys."""
+    keys = tuple(dict.fromkeys(cache_keys))
+    if not keys:
+        return {}
+    if not _supports_get_many(cache_backend):
+        return _read_many_without_get_many(cache_backend, keys)
+
+    payloads = cache_backend.get_many(keys)
+    hits: dict[str, DependencyCacheHit] = {}
+    legacy_keys: list[str] = []
+    for key in keys:
+        if key not in payloads:
+            continue
+        combined_hit = _combined_payload_to_hit(payloads[key])
+        if combined_hit is _MISSING:
+            continue
+        if isinstance(combined_hit, DependencyCacheHit):
+            hits[key] = combined_hit
+            continue
+        legacy_keys.append(key)
+
+    if legacy_keys:
+        deps_keys = {_legacy_deps_key(key): key for key in legacy_keys}
+        legacy_deps = cache_backend.get_many(deps_keys.keys())
+        for deps_key, key in deps_keys.items():
+            hits[key] = DependencyCacheHit(
+                value=payloads[key],
+                dependencies=frozenset(legacy_deps.get(deps_key, ()) or ()),
+            )
+    return hits
+
+
+def replay_dependency_cache_hit(hit: DependencyCacheHit) -> None:
+    """Replay cached dependencies into active dependency tracking scopes."""
+    for class_name, operation, identifier in hit.dependencies:
+        DependencyTracker.track(class_name, operation, identifier)
+
+
+def _legacy_deps_key(cache_key: str) -> str:
+    return f"{cache_key}:deps"
+
+
+def _combined_payload_to_hit(payload: Any) -> DependencyCacheHit | None | object:
+    if not isinstance(payload, DependencyCacheEntry):
+        return None
+    if payload.version != DEPENDENCY_CACHE_ENTRY_VERSION:
+        return _MISSING
+    return DependencyCacheHit(
+        value=payload.value,
+        dependencies=payload.dependencies,
+    )
+
+
+def _supports_get_many(
+    cache_backend: DependencyCacheBackend,
+) -> TypeGuard[DependencyCacheGetManyBackend]:
+    return callable(getattr(cache_backend, "get_many", None))
+
+
+def _read_many_without_get_many(
+    cache_backend: DependencyCacheBackend,
+    cache_keys: tuple[str, ...],
+) -> dict[str, DependencyCacheHit]:
+    hits: dict[str, DependencyCacheHit] = {}
+    for key in cache_keys:
+        hit = read_dependency_cache_hit(cache_backend, key, sentinel=_MISSING)
+        if hit is not _MISSING:
+            hits[key] = hit
+    return hits

{generalmanager-0.46.0 → generalmanager-0.46.1}/src/general_manager/cache/dependency_publish.py

@@ -5,10 +5,15 @@ from __future__ import annotations
 import time
 import uuid
 from dataclasses import dataclass
-from typing import Any, Callable, Iterable, Protocol
+from typing import Any, Callable, Iterable
 
 from django.core.cache import cache as coordination_cache
 
+from general_manager.cache.dependency_cache import (
+    DependencyCacheBackend,
+    make_dependency_cache_entry,
+    read_dependency_cache_hit,
+)
 from general_manager.cache.dependency_index import (
     LOCK_TIMEOUT,
     Dependency,
@@ -34,14 +39,6 @@ class CacheComputeLease:
     token: str
 
 
-class DependencyCacheBackend(Protocol):
-    def get(self, key: str, default: Any = None) -> Any:
-        raise NotImplementedError
-
-    def set(self, key: str, value: Any, timeout: int | None = None) -> None:
-        raise NotImplementedError
-
-
 RecordManyDependenciesFn = Callable[[Iterable[tuple[str, Iterable[Dependency]]]], None]
 
 COMPUTE_LOCK_PREFIX = "dependency_cache_compute_lock"
@@ -72,26 +69,32 @@ def release_compute_lease(lease: CacheComputeLease) -> None:
     """Release a compute lease without risking deletion of a newer owner.
 
     Django's cache API does not provide an atomic compare-and-delete operation.
-    Leaving the lease to expire avoids a check-then-delete race where an expired
-    lease could delete another worker's freshly acquired token.
+    Checking the owner token first keeps normal recomputes fast while avoiding
+    deletion when the lease has already been replaced by another worker.
     """
-    return None
+    if coordination_cache.get(lease.key) != lease.token:
+        return
+    coordination_cache.delete(lease.key)
 
 
-def wait_for_cached_dependency_value(
+def wait_for_cached_dependency_hit(
     cache_backend: DependencyCacheBackend,
     cache_key: str,
     timeout_seconds: float = LOCK_TIMEOUT,
     sentinel: Any = _WAIT_MISS,
 ) -> Any:
-    """Poll for a cached dependency value until it appears or the wait expires."""
+    """Poll for a dependency-cache hit until it appears or the wait expires."""
     deadline = time.monotonic() + timeout_seconds
     delay = WAIT_INITIAL_DELAY
 
     while True:
-        cached_value = cache_backend.get(cache_key, sentinel)
-        if cached_value is not sentinel:
-            return cached_value
+        cached_hit = read_dependency_cache_hit(
+            cache_backend,
+            cache_key,
+            sentinel=sentinel,
+        )
+        if cached_hit is not sentinel:
+            return cached_hit
 
         remaining = deadline - time.monotonic()
         if remaining <= 0:
@@ -111,7 +114,6 @@ def _ensure_publish_current(started_generation: int) -> None:
 def publish_dependency_cache_entry(
     *,
     cache_key: str,
-    deps_key: str,
     result: Any,
     dependencies: Iterable[Dependency],
     cache_backend: DependencyCacheBackend,
@@ -142,12 +144,12 @@ def publish_dependency_cache_entry(
             if dependency_set:
                 _record_dependencies_locked(idx, cache_key, dependency_set)
             _ensure_publish_current(started_generation)
-            cache_backend.set(deps_key, dependency_set, timeout)
             set_full_index(idx)
-            cache_backend.set(cache_key, result, timeout)
-            return
 
-        cache_backend.set(deps_key, dependency_set, timeout)
-        cache_backend.set(cache_key, result, timeout)
+        cache_backend.set(
+            cache_key,
+            make_dependency_cache_entry(result, dependency_set),
+            timeout,
+        )
     finally:
         release_lock()