GeneralManager 0.60.1__tar.gz → 0.60.2__tar.gz

{generalmanager-0.60.1/src/GeneralManager.egg-info → generalmanager-0.60.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.60.1
+Version: 0.60.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.60.1 → generalmanager-0.60.2}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.60.1
+Version: 0.60.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.60.1 → generalmanager-0.60.2}/src/general_manager/api/property.py

@@ -142,7 +142,10 @@ class GraphQLProperty(property):
         @wraps(fget)
         def resolver(instance: object) -> object:
             """Resolve the property through the selected cached wrapper."""
-            return self._get_cached_fget()(instance)
+            cached_fget = self._cached_fget
+            if cached_fget is None:
+                cached_fget = self._get_cached_fget()
+            return cached_fget(instance)
 
         super().__init__(resolver, doc=doc)
         self.is_graphql_resolver = True

{generalmanager-0.60.1 → generalmanager-0.60.2}/src/general_manager/bucket/database_bucket.py

@@ -11,7 +11,10 @@ from django.db.models.sql.query import Query
 
 from general_manager.bucket.base_bucket import Bucket
 from general_manager.cache.cache_tracker import DependencyTracker
-from general_manager.cache.dependency_index import serialize_dependency_identifier
+from general_manager.cache.dependency_index import (
+    Dependency,
+    serialize_dependency_identifier,
+)
 from general_manager.cache.run_context import current_calculation_run_context
 from general_manager.manager.general_manager import GeneralManager
 from general_manager.utils.filter_parser import create_filter_function
@@ -605,10 +608,29 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
     def _can_cache_run_scoped_managers(self) -> bool:
         if self._manager_class.__init__ is not GeneralManager.__init__:
             return False
+        if not type.__getattribute__(
+            self._manager_class,
+            "_gm_uses_default_identification_dependency_active",
+        ):
+            return False
         return callable(
             getattr(self._manager_class.Interface, "_from_trusted_orm_instance", None)
         )
 
+    def _manager_identification_dependencies(
+        self,
+        managers: tuple[GeneralManagerType, ...],
+    ) -> frozenset[Dependency]:
+        manager_name = type.__getattribute__(self._manager_class, "__name__")
+        return frozenset(
+            (
+                manager_name,
+                "identification",
+                serialize_dependency_identifier(manager.identification),
+            )
+            for manager in managers
+        )
+
     def _get_run_scoped_managers(self) -> tuple[GeneralManagerType, ...] | None:
         """Load or reuse manager wrappers for a trusted row snapshot."""
         if not self._can_cache_run_scoped_managers():
@@ -622,16 +644,24 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         cached = context.get_orm_bucket_managers(signature)
         if cached is not None:
             managers = cast(tuple[GeneralManagerType, ...], cached)
-            for manager in managers:
-                self._manager_class._track_identification_dependency(
-                    manager.identification
-                )
+            dependencies = context.get_orm_bucket_manager_dependencies(signature)
+            if dependencies is not None:
+                DependencyTracker._track_many_validated(dependencies)
+            else:
+                for manager in managers:
+                    self._manager_class._track_identification_dependency(
+                        manager.identification
+                    )
             return managers
         rows = self._get_run_scoped_rows()
         if rows is None:
             return None
         managers = tuple(self._build_manager_from_instance(row) for row in rows)
-        context.set_orm_bucket_managers(signature, managers)
+        context.set_orm_bucket_managers(
+            signature,
+            managers,
+            self._manager_identification_dependencies(managers),
+        )
         return managers
 
     @staticmethod
@@ -675,9 +705,18 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
     def _track_effective_dependencies(self) -> None:
         """Record the bucket's effective filter/exclude state when it is evaluated."""
-        manager_name = self._manager_class.__name__
-        normalized_filters = self._normalize_dependency_mapping(self.filters)
-        normalized_excludes = self._normalize_dependency_mapping(self.excludes)
+        manager_name = type.__getattribute__(self._manager_class, "__name__")
+        needs_sort_payload = bool(self._sort_keys)
+        normalized_filters = (
+            self._normalize_dependency_mapping(self.filters)
+            if self.filters or needs_sort_payload
+            else {}
+        )
+        normalized_excludes = (
+            self._normalize_dependency_mapping(self.excludes)
+            if self.excludes or needs_sort_payload
+            else {}
+        )
         if self.filters:
             DependencyTracker._track_validated(
                 manager_name,

{generalmanager-0.60.1 → generalmanager-0.60.2}/src/general_manager/cache/cache_decorator.py

@@ -2,6 +2,7 @@
 
 from collections.abc import Callable, Iterable
 from functools import wraps
+from hashlib import sha256
 from typing import (
     Literal,
     Protocol,
@@ -15,6 +16,16 @@ 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,
+    dependency_cache_prefetch_bundle_key,
+    dependency_cache_prefetch_segment_bundle_key,
+    dependency_cache_prefetch_segment_index_key,
+    dependency_cache_prefetch_segment_value_bundle_key,
+    dependency_cache_prefetch_value_bundle_key,
+    read_many_dependency_cache_hits,
+    read_many_dependency_cache_prefetch_bundle_hits,
+    read_many_dependency_cache_prefetch_bundle_values,
+    read_dependency_cache_prefetch_bundle_hits,
+    read_dependency_cache_prefetch_bundle_values,
     read_dependency_cache_hit,
     replay_dependency_cache_hit,
 )
@@ -63,6 +74,10 @@ FuncT = TypeVar("FuncT", bound=Callable[..., object])
 CacheScope = Literal["dependency", "run", "timeout", "none"]
 
 _SENTINEL = object()
+_RUN_CACHE_MISS = object()
+_DEPENDENCY_CACHE_PREFETCH_MANIFEST_PREFIX = "dependency_cache_prefetch_manifest"
+_DEPENDENCY_CACHE_PREFETCH_ATTEMPT_PREFIX = "dependency_cache_prefetch_attempt"
+_DEPENDENCY_CACHE_PREFETCH_VALUE_PREFIX = "dependency_cache_prefetch_value"
 logger = get_logger("cache.decorator")
 
 
@@ -169,7 +184,130 @@ def cached(
     if timeout is not None and cache != "timeout":
         raise CacheTimeoutConfigurationError.unexpected_timeout()
 
+    def dependency_cache_prefetch_manifest_key(
+        decorated_func: Callable[..., object],
+    ) -> str:
+        raw = f"{decorated_func.__module__}:{decorated_func.__qualname__}".encode()
+        digest = sha256(raw, usedforsecurity=False).hexdigest()
+        return f"{_DEPENDENCY_CACHE_PREFETCH_MANIFEST_PREFIX}:{digest}"
+
+    def prefetch_dependency_cache_manifest(
+        context: object,
+        manifest_key: str,
+    ) -> None:
+        if not callable(getattr(cache_backend, "get_many", None)):
+            return
+        if not all(
+            hasattr(context, attr)
+            for attr in (
+                "get",
+                "set",
+                "set_dependency_cache_hits",
+            )
+        ):
+            return
+        attempt_key = (
+            _DEPENDENCY_CACHE_PREFETCH_ATTEMPT_PREFIX,
+            id(cache_backend),
+            manifest_key,
+        )
+        if context.get(attempt_key, False):  # type: ignore[attr-defined]
+            return
+        context.set(attempt_key, True)  # type: ignore[attr-defined]
+
+        segment_tokens = cache_backend.get(
+            dependency_cache_prefetch_segment_index_key(manifest_key),
+            (),
+        )
+        if isinstance(segment_tokens, (tuple, list, frozenset, set)):
+            valid_segment_tokens = tuple(
+                token for token in segment_tokens if isinstance(token, str)
+            )
+        else:
+            valid_segment_tokens = ()
+
+        if not DependencyTracker.is_active():
+            if valid_segment_tokens:
+                segment_value_keys = tuple(
+                    dependency_cache_prefetch_segment_value_bundle_key(
+                        manifest_key,
+                        segment_token,
+                    )
+                    for segment_token in valid_segment_tokens
+                )
+                segment_values = read_many_dependency_cache_prefetch_bundle_values(
+                    cache_backend,
+                    segment_value_keys,
+                )
+                if segment_values:
+                    for cache_key, value in segment_values.items():
+                        context.set(  # type: ignore[attr-defined]
+                            (
+                                _DEPENDENCY_CACHE_PREFETCH_VALUE_PREFIX,
+                                id(cache_backend),
+                                cache_key,
+                            ),
+                            value,
+                        )
+                    return
+
+            bundle_values = read_dependency_cache_prefetch_bundle_values(
+                cache_backend,
+                dependency_cache_prefetch_value_bundle_key(manifest_key),
+            )
+            if bundle_values:
+                for cache_key, value in bundle_values.items():
+                    context.set(  # type: ignore[attr-defined]
+                        (
+                            _DEPENDENCY_CACHE_PREFETCH_VALUE_PREFIX,
+                            id(cache_backend),
+                            cache_key,
+                        ),
+                        value,
+                    )
+                return
+
+        if valid_segment_tokens:
+            segment_bundle_keys = tuple(
+                dependency_cache_prefetch_segment_bundle_key(
+                    manifest_key,
+                    segment_token,
+                )
+                for segment_token in valid_segment_tokens
+            )
+            segment_hits = read_many_dependency_cache_prefetch_bundle_hits(
+                cache_backend,
+                segment_bundle_keys,
+            )
+            if segment_hits:
+                context.set_dependency_cache_hits(segment_hits)  # type: ignore[attr-defined]
+                return
+
+        bundle_hits = read_dependency_cache_prefetch_bundle_hits(
+            cache_backend,
+            dependency_cache_prefetch_bundle_key(manifest_key),
+        )
+        if bundle_hits:
+            context.set_dependency_cache_hits(bundle_hits)  # type: ignore[attr-defined]
+            return
+
+        manifest = cache_backend.get(manifest_key, ())
+        if not isinstance(manifest, (tuple, list, frozenset, set)):
+            return
+        cache_keys = tuple(key for key in manifest if isinstance(key, str))
+        if not cache_keys:
+            return
+        hits = read_many_dependency_cache_hits(cache_backend, cache_keys)
+        if hits:
+            context.set_dependency_cache_hits(hits)  # type: ignore[attr-defined]
+
     def decorator(decorated_func: FuncT) -> FuncT:
+        prefetch_manifest_key = (
+            dependency_cache_prefetch_manifest_key(decorated_func)
+            if cache == "dependency"
+            else None
+        )
+
         @wraps(decorated_func)
         def wrapper(*args: object, **kwargs: object) -> object:
             if cache == "none":
@@ -177,11 +315,21 @@ def cached(
 
             if cache == "run":
                 key = make_cache_key(decorated_func, args, kwargs)
+                active_context = current_calculation_run_context()
+                if active_context is not None:
+                    cached_run_value = active_context.get(key, _RUN_CACHE_MISS)
+                    if cached_run_value is not _RUN_CACHE_MISS:
+                        return cached_run_value
+                    result = decorated_func(*args, **kwargs)
+                    active_context.set(key, result)
+                    return result
                 with ensure_calculation_run_context() as context:
-                    return context.get_or_set(
-                        key,
-                        lambda: decorated_func(*args, **kwargs),
-                    )
+                    cached_run_value = context.get(key, _RUN_CACHE_MISS)
+                    if cached_run_value is not _RUN_CACHE_MISS:
+                        return cached_run_value
+                    result = decorated_func(*args, **kwargs)
+                    context.set(key, result)
+                    return result
 
             key = make_cache_key(decorated_func, args, kwargs)
 
@@ -223,8 +371,23 @@ def cached(
                 )
                 return hit.value
 
+            def prefetched_value_from_context(context: object) -> object:
+                if DependencyTracker.is_active():
+                    return _SENTINEL
+                return context.get(  # type: ignore[attr-defined]
+                    (
+                        _DEPENDENCY_CACHE_PREFETCH_VALUE_PREFIX,
+                        id(cache_backend),
+                        key,
+                    ),
+                    _SENTINEL,
+                )
+
             prefetch_context = current_calculation_run_context()
             if prefetch_context is not None:
+                prefetched_value = prefetched_value_from_context(prefetch_context)
+                if prefetched_value is not _SENTINEL:
+                    return prefetched_value
                 prefetched_hit = prefetch_context.get_dependency_cache_hit(
                     key, _SENTINEL
                 )
@@ -233,6 +396,22 @@ def cached(
                         prefetched_hit,
                         "cache hit from dependency prefetch",
                     )
+                if prefetch_manifest_key is not None:
+                    prefetch_dependency_cache_manifest(
+                        prefetch_context,
+                        prefetch_manifest_key,
+                    )
+                    prefetched_value = prefetched_value_from_context(prefetch_context)
+                    if prefetched_value is not _SENTINEL:
+                        return prefetched_value
+                    prefetched_hit = prefetch_context.get_dependency_cache_hit(
+                        key, _SENTINEL
+                    )
+                    if isinstance(prefetched_hit, DependencyCacheHit):
+                        return return_cached_hit(
+                            prefetched_hit,
+                            "cache hit from dependency prefetch manifest",
+                        )
 
             cached_hit = read_dependency_cache_hit(
                 cache_backend,
@@ -288,6 +467,10 @@ def cached(
                             timeout=timeout,
                             started_generation=started_generation,
                             lease=lease,
+                            dependencies_trusted=DependencyTracker._dependencies_are_tracker_captured(
+                                dependencies
+                            ),
+                            prefetch_manifest_key=prefetch_manifest_key,
                         )
                     )
                     lease_transferred_to_context = True
@@ -305,6 +488,7 @@ def cached(
                                 if record_fn is record_dependencies
                                 else record_many
                             ),
+                            prefetch_manifest_key=prefetch_manifest_key,
                         )
                     except CachePublishAborted:
                         logger.debug(

{generalmanager-0.60.1 → generalmanager-0.60.2}/src/general_manager/cache/cache_tracker.py

@@ -1,5 +1,6 @@
 """Context manager utilities for tracking cache dependencies per thread."""
 
+from collections.abc import Collection, Iterable
 import threading
 from types import TracebackType
 
@@ -30,18 +31,32 @@ class _InvalidDependencyTrackerOperationError(ValueError):
         super().__init__(f"Unsupported dependency tracker operation: {operation!r}")
 
 
+class _TrackedDependencySet(set[Dependency]):
+    """Dependency set returned by DependencyTracker for framework-captured deps."""
+
+
 class _DependencyStorage(threading.local):
     """Thread-local dependency tracking stack."""
 
     def __init__(self) -> None:
         """Initialize an inactive dependency stack for one thread."""
-        self.dependencies: list[set[Dependency]] = []
+        self.dependencies: list[_TrackedDependencySet] = []
         self.depth = -1
+        self.stack_version = 0
+        self.last_dependency: Dependency | None = None
+        self.last_dependency_stack_version = -1
+        self.seen_dependencies: set[Dependency] = set()
+        self.seen_dependencies_stack_version = -1
 
     def reset(self) -> None:
         """Clear all active dependency scopes for the current thread."""
         self.dependencies.clear()
         self.depth = -1
+        self.stack_version += 1
+        self.last_dependency = None
+        self.last_dependency_stack_version = -1
+        self.seen_dependencies.clear()
+        self.seen_dependencies_stack_version = -1
 
 
 _dependency_storage = _DependencyStorage()
@@ -69,7 +84,8 @@ class DependencyTracker:
             thread-local storage does not mutate sets that were already returned.
         """
         _dependency_storage.depth += 1
-        _dependency_storage.dependencies.append(set())
+        _dependency_storage.dependencies.append(_TrackedDependencySet())
+        _dependency_storage.stack_version += 1
         return _dependency_storage.dependencies[_dependency_storage.depth]
 
     def __exit__(
@@ -98,6 +114,9 @@ class DependencyTracker:
             return
         _dependency_storage.dependencies.pop()
         _dependency_storage.depth -= 1
+        _dependency_storage.stack_version += 1
+        _dependency_storage.last_dependency = None
+        _dependency_storage.last_dependency_stack_version = -1
 
     @staticmethod
     def track(
@@ -144,11 +163,50 @@ class DependencyTracker:
         identifier: str,
     ) -> None:
         """Record an already-validated dependency tuple in active collectors."""
-        if _dependency_storage.depth < 0:
+        storage = _dependency_storage
+        if storage.depth < 0:
             return
+        if storage.last_dependency_stack_version == storage.stack_version:
+            last_dependency = storage.last_dependency
+            if (
+                last_dependency is not None
+                and last_dependency[0] == class_name
+                and last_dependency[1] == operation
+                and last_dependency[2] == identifier
+            ):
+                return
         dependency = (class_name, operation, identifier)
+        if storage.seen_dependencies_stack_version != storage.stack_version:
+            storage.seen_dependencies.clear()
+            storage.seen_dependencies_stack_version = storage.stack_version
+        elif dependency in storage.seen_dependencies:
+            return
+        if storage.depth == 0:
+            storage.dependencies[0].add(dependency)
+        else:
+            for dep_set in storage.dependencies:
+                dep_set.add(dependency)
+        storage.last_dependency = dependency
+        storage.last_dependency_stack_version = storage.stack_version
+        storage.seen_dependencies.add(dependency)
+
+    @staticmethod
+    def _track_many_validated(dependencies: Iterable[Dependency]) -> None:
+        """Record already-validated dependency tuples in active collectors."""
+        if _dependency_storage.depth < 0:
+            return
+        reusable_dependencies: Collection[Dependency]
+        if isinstance(dependencies, Collection):
+            reusable_dependencies = dependencies
+        else:
+            reusable_dependencies = tuple(dependencies)
         for dep_set in _dependency_storage.dependencies:
-            dep_set.add(dependency)
+            dep_set.update(reusable_dependencies)
+
+    @staticmethod
+    def _dependencies_are_tracker_captured(dependencies: object) -> bool:
+        """Return whether dependencies came from this tracker implementation."""
+        return isinstance(dependencies, _TrackedDependencySet)
 
     @staticmethod
     def is_active() -> bool: