GeneralManager 0.80.5__tar.gz → 0.80.7__tar.gz

{generalmanager-0.80.5/src/GeneralManager.egg-info → generalmanager-0.80.7}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.80.5
+Version: 0.80.7
 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.5 → generalmanager-0.80.7}/src/general_manager/measurement/measurement.py

@@ -6,7 +6,14 @@ from collections.abc import Callable
 from functools import lru_cache
 from typing import TypeAlias, TypeGuard, cast
 import pint
-from decimal import Decimal, InvalidOperation, ROUND_HALF_EVEN, getcontext, localcontext
+from decimal import (
+    Context,
+    Decimal,
+    InvalidOperation,
+    ROUND_HALF_EVEN,
+    getcontext,
+    localcontext,
+)
 from operator import lt, le, gt, ge
 from pint.facets.plain import PlainQuantity
 from pint.util import UnitsContainer
@@ -77,8 +84,29 @@ def _format_decimal(value: Decimal) -> Decimal:
     Returns:
         Decimal: Normalised decimal with insignificant trailing zeros removed.
     """
+    if type(value) is Decimal:
+        parts = value.as_tuple()
+        exponent = parts.exponent
+        precision = max(28, len(parts.digits)) if isinstance(exponent, int) else 28
+        if isinstance(exponent, int):
+            context = getcontext()
+            # These representations already match normalize/quantize at the
+            # coefficient precision below. Exponent limits and clamp still
+            # require the Decimal pipeline, even for an unchanged coefficient.
+            if (
+                type(context) is Context
+                and not context.clamp
+                and context.Emin <= value.adjusted() <= context.Emax
+                and (exponent == 0 or (exponent < 0 and parts.digits[-1] != 0))
+            ):
+                # Keep the distinct result object (also observable in pickles)
+                # without applying context rounding or discarding signed zero.
+                return value.copy_sign(value)
+    else:
+        # Preserve Decimal subclass methods and their observable side effects.
+        precision = None
     with localcontext() as context:
-        context.prec = _decimal_precision(value)
+        context.prec = _decimal_precision(value) if precision is None else precision
         normalized = value.normalize(context=context)
         if normalized == normalized.to_integral_value(context=context):
             try:

{generalmanager-0.80.5 → generalmanager-0.80.7}/src/general_manager/utils/_cache_key_encoder.py

@@ -88,7 +88,9 @@ def _encode_time(value: time) -> list[object]:
     ]
 
 
-def _encode_manager(value: object, active_ids: set[int]) -> list[object]:
+def _encode_manager(
+    value: object, active_ids: set[int], *, frozen: bool = False
+) -> object:
     manager = cast("GeneralManager", value)
     manager_type = type(manager)
     missing = object()
@@ -99,20 +101,76 @@ def _encode_manager(value: object, active_ids: set[int]) -> list[object]:
         )
 
         search_date = _legacy_effective_search_date(manager)
-    snapshot: object = (
+    snapshot: list[object] = (
         ["none"]
         if not isinstance(search_date, datetime)
         else ["as_of", search_date_cache_fingerprint(search_date)]
     )
+    module = type.__getattribute__(manager_type, "__module__")
+    qualname = type.__getattribute__(manager_type, "__qualname__")
+    identification = manager.identification
+    if frozen:
+        if type(module) is not str or type(qualname) is not str:
+            # Unusual mutable class metadata must be frozen only after identity
+            # conversion, matching the generic path's side effects and errors.
+            return freeze_encoded_cache_key_value(
+                [
+                    "manager",
+                    module,
+                    qualname,
+                    encode_cache_key_value(identification, active_ids),
+                    snapshot,
+                ]
+            )
+        return (
+            "manager",
+            module,
+            qualname,
+            _freeze_manager_identification(identification, active_ids),
+            tuple(snapshot),
+        )
     return [
         "manager",
-        type.__getattribute__(manager_type, "__module__"),
-        type.__getattribute__(manager_type, "__qualname__"),
-        encode_cache_key_value(manager.identification, active_ids),
+        module,
+        qualname,
+        encode_cache_key_value(identification, active_ids),
         snapshot,
     ]
 
 
+def _freeze_manager_identification(value: object, active_ids: set[int]) -> object:
+    # Only exact builtins bypass the generic encoder: subclasses can customize
+    # iteration or conversion. Read the current identity on every call.
+    if type(value) is dict and len(value) == 1:
+        key, item = next(iter(value.items()))
+        if type(key) is str:
+            item_type = type(item)
+            encoded: tuple[object, ...] | None = None
+            if item_type is int:
+                encoded = ("int", str(item))
+            elif item_type is str:
+                encoded = ("str", item)
+            elif item_type is bool:
+                encoded = ("bool", item)
+            elif item is None:
+                encoded = ("none",)
+            if encoded is not None:
+                return ("mapping", ((("str", key), encoded),))
+    return freeze_encoded_cache_key_value(encode_cache_key_value(value, active_ids))
+
+
+def encode_frozen_manager_cache_key_value(value: object) -> object:
+    """Encode a known manager directly into the existing immutable key format."""
+    # Multiple inheritance can give a manager a scalar identity. Preserve the
+    # generic encoder's scalar-before-manager dispatch, including its errors.
+    if isinstance(
+        value,
+        (int, float, Decimal, str, bytes, UUID, date, time, timedelta, Measurement),
+    ):
+        return freeze_encoded_cache_key_value(encode_cache_key_value(value))
+    return _encode_manager(value, {id(value)}, frozen=True)
+
+
 @lru_cache(maxsize=1)
 def _general_manager_class() -> type[object]:
     from general_manager.manager.general_manager import GeneralManager

{generalmanager-0.80.5 → generalmanager-0.80.7}/src/general_manager/utils/_make_cache_key.py

@@ -9,7 +9,7 @@ from general_manager.as_of import as_of_cache_fingerprint
 from general_manager.utils._cache_key_encoder import (
     canonical_cache_key_json,
     encode_cache_key_value,
-    freeze_encoded_cache_key_value,
+    encode_frozen_manager_cache_key_value,
     is_general_manager,
 )
 
@@ -118,7 +118,7 @@ def _single_manager_arg_fast_key(
 ) -> str | None:
     if not is_general_manager(value):
         return None
-    encoded_manager = freeze_encoded_cache_key_value(encode_cache_key_value(value))
+    encoded_manager = encode_frozen_manager_cache_key_value(value)
     return _single_manager_arg_cache_key(
         parameter_name,
         func.__module__,