GeneralManager 0.80.4__tar.gz → 0.80.6__tar.gz

{generalmanager-0.80.4/src/GeneralManager.egg-info → generalmanager-0.80.6}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.80.4
+Version: 0.80.6
 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.4 → generalmanager-0.80.6}/src/general_manager/manager/meta.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Iterator, Mapping
 from functools import wraps
 import threading
 from _thread import RLock as RLockType
@@ -781,6 +781,17 @@ class GeneralManagerMeta(type):
                 ) -> None:
                     self._attr_name = descriptor_attr_name
                     self._class = descriptor_class
+                    # Keep a live view: validation can be reset after installation.
+                    # Custom metaclasses retain their observable dictionary lookups.
+                    self._standard_class_dict: Mapping[str, object] | None = (
+                        vars(descriptor_class)
+                        if (
+                            type(descriptor_class) is GeneralManagerMeta
+                            and _STANDARD_MANAGER_META_DICT.get("__getattribute__")
+                            is _STANDARD_MANAGER_META_GETATTRIBUTE
+                        )
+                        else None
+                    )
                     # Excel values can change outside this manager instance.
                     self._cache_values = (
                         getattr(descriptor_class.Interface, "_interface_type", None)
@@ -826,9 +837,17 @@ class GeneralManagerMeta(type):
                     """
                     if instance is None:
                         return self._class.Interface.get_field_type(self._attr_name)
-                    GeneralManagerMeta.ensure_rule_templates_validated_after_readiness(
-                        self._class
-                    )
+                    class_dict = self._standard_class_dict
+                    if (
+                        class_dict is None
+                        or type(self._class) is not GeneralManagerMeta
+                        or _STANDARD_MANAGER_META_DICT.get("__getattribute__")
+                        is not _STANDARD_MANAGER_META_GETATTRIBUTE
+                        or class_dict.get("_gm_rule_templates_validated") is not True
+                    ):
+                        GeneralManagerMeta.ensure_rule_templates_validated_after_readiness(
+                            self._class
+                        )
                     try:
                         ensure_as_of_compatible = object.__getattribute__(
                             instance, "_ensure_as_of_compatible"
@@ -940,6 +959,10 @@ class GeneralManagerMeta(type):
         type.__setattr__(new_class, "_gm_attributes_initialized", True)
 
 
+# In-place metaclass customization must retain observable dictionary lookups.
+_STANDARD_MANAGER_META_GETATTRIBUTE = GeneralManagerMeta.__getattribute__
+_STANDARD_MANAGER_META_DICT = vars(GeneralManagerMeta)
+
 _CAPABILITY_BUILDER: "ManifestCapabilityBuilder | None" = None
 
 

{generalmanager-0.80.4 → generalmanager-0.80.6}/src/general_manager/measurement/measurement.py

@@ -6,7 +6,7 @@ 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, localcontext
+from decimal import 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
@@ -58,6 +58,15 @@ def _canonical_unit_string(unit: str) -> str:
     return str(parsed_unit)
 
 
+@lru_cache(maxsize=512)
+def _default_quantity_unit(unit: str) -> pint.Unit:
+    """Cache the legacy unit round trip for the default Pint formatter only."""
+
+    # Pint's display can round fractional exponents. Retain that round trip
+    # without relying on a public label cached under a previous formatter.
+    return _parse_unit(str(_parse_unit(unit)))
+
+
 def _format_decimal(value: Decimal) -> Decimal:
     """
     Normalise decimals so integers have no fractional component.
@@ -82,6 +91,13 @@ def _format_decimal(value: Decimal) -> Decimal:
 def _decimal_precision(*values: Decimal, extra_digits: int = 0) -> int:
     """Return enough local precision to retain all supplied Decimal coefficients."""
 
+    if len(values) == 1:
+        value = values[0]
+        if not value.is_finite():
+            return max(28, extra_digits)
+        # For one coefficient, adjusted - exponent + 1 is its digit count.
+        return max(28, len(value.as_tuple().digits)) + extra_digits
+
     finite_values = [value for value in values if value.is_finite()]
     coefficient_digits = sum(len(value.as_tuple().digits) for value in finite_values)
     if not finite_values:
@@ -734,7 +750,7 @@ class Measurement:
     version and are not a stable GeneralManager API contract.
     """
 
-    __quantity: MeasurementQuantity | None
+    __quantity: MeasurementQuantity | pint.Unit | None
     __magnitude: Decimal
     __unit: str
     __quantity_exposed: bool
@@ -744,8 +760,9 @@ class Measurement:
         Create a Measurement from a numeric value and a unit label.
 
         Converts the provided numeric-like value to a Decimal through
-        ``Decimal(str(value))`` and constructs the internal quantity using the
-        given Pint unit expression. ``unit`` may be ``"dimensionless"`` or an
+        ``Decimal(str(value))`` and validates the given Pint unit expression.
+        Ordinary values defer the internal Pint quantity until it is needed.
+        ``unit`` may be ``"dimensionless"`` or an
         empty string for dimensionless measurements. Discrete item quantities
         should use ``"count"``, which belongs to its own unit family rather than
         Pint's plain dimensionless family. Invalid units are reported by Pint and
@@ -784,6 +801,29 @@ class Measurement:
                 value = Decimal(str(value))
             except (InvalidOperation, TypeError, ValueError) as error:
                 raise InvalidMeasurementInitializationError() from error
+        self.__set_value(value, unit)
+
+    def __set_value(self, value: Decimal, unit: str) -> None:
+        """Validate scalar parts eagerly and defer ordinary Pint allocations."""
+
+        # Normalization is idempotent for normal values and zeros without clamp.
+        # Subnormals can change again as their coefficient (and local precision)
+        # shrinks; preserve the original Pint/Decimal pipeline for those cases.
+        if (
+            not getcontext().clamp
+            and (value.is_normal() or value.is_zero())
+            and not ureg.formatter.default_format
+        ):
+            magnitude = _decimal_from_magnitude(value)
+            canonical_unit = _canonical_unit_string(unit)
+            # Keep immutable internal units separate from the public label,
+            # which may have been cached under a different Pint formatter.
+            self.__quantity = _default_quantity_unit(unit)
+            self.__magnitude = magnitude
+            self.__unit = canonical_unit
+            self.__quantity_exposed = False
+            return
+        # Custom formatters must retain the eager unit reparse and its errors.
         self.__set_quantity(_build_quantity(value, unit), _canonical_unit_string(unit))
 
     @classmethod
@@ -828,10 +868,13 @@ class Measurement:
 
     def __current_quantity(self) -> MeasurementQuantity:
         quantity = self.__quantity
-        if quantity is None:
+        if not isinstance(quantity, PlainQuantity):
             quantity = cast(
                 MeasurementQuantity,
-                ureg.Quantity(self.__magnitude, _parse_unit(self.__unit)),
+                ureg.Quantity(
+                    self.__magnitude,
+                    quantity if quantity is not None else _parse_unit(self.__unit),
+                ),
             )
             self.__quantity = quantity
         return quantity
@@ -867,7 +910,7 @@ class Measurement:
         """
         value = Decimal(state["magnitude"])
         unit = state["unit"]
-        self.__set_quantity(_build_quantity(value, unit), _canonical_unit_string(unit))
+        self.__set_value(value, unit)
 
     def deconstruct(self) -> tuple[str, list[object], dict[str, object]]:
         """Describe this value for Django migration serialization.

{generalmanager-0.80.4 → generalmanager-0.80.6}/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.4 → generalmanager-0.80.6}/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__,