GeneralManager 0.80.3__tar.gz → 0.80.5__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.80.3
+Version: 0.80.5
 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.3 → generalmanager-0.80.5}/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.3 → generalmanager-0.80.5}/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.3 → generalmanager-0.80.5}/src/general_manager/search/backends/meilisearch.py

@@ -6,6 +6,7 @@ import hashlib
 import time
 from collections.abc import Callable, Iterable
 from importlib import import_module
+from inspect import signature
 from typing import Mapping, Protocol, Sequence, cast
 
 from general_manager.search.backend import (
@@ -83,7 +84,7 @@ class _MeilisearchClientWithGetOrCreate(_MeilisearchClient, Protocol):
 class _MeilisearchClientWithWait(_MeilisearchClient, Protocol):
     """Client variant exposing server-side task waiting."""
 
-    def wait_for_task(self, task_uid: object) -> object: ...
+    def wait_for_task(self, task_uid: object, *, timeout_in_ms: int) -> object: ...
 
 
 class _MeilisearchClientWithGetTask(_MeilisearchClient, Protocol):
@@ -111,6 +112,7 @@ class MeilisearchBackend:
         url: str = "http://127.0.0.1:7700",
         api_key: str | None = None,
         client: _MeilisearchClient | None = None,
+        task_timeout_in_ms: int = 5000,
     ) -> None:
         """
         Initialize the backend with a provided Meilisearch client or a new one.
@@ -124,6 +126,10 @@ class MeilisearchBackend:
                 `meilisearch` package and instantiates a client with `url` and
                 `api_key`; if the package is not available, raises
                 SearchBackendClientMissingError("Meilisearch").
+            task_timeout_in_ms: Timeout in milliseconds forwarded to the client
+                `wait_for_task` method. Defaults to 5000 (five seconds). Does not
+                affect fallback polling for clients exposing only `get_task`
+                or legacy clients whose wait method does not accept the timeout.
 
         Raises:
             SearchBackendClientMissingError: The `meilisearch` package is not
@@ -137,6 +143,7 @@ class MeilisearchBackend:
             client_factory = cast(_MeilisearchModule, meilisearch_module).Client
             client = client_factory(url, api_key)
         self._client = client
+        self._task_timeout_in_ms = task_timeout_in_ms
 
     def ensure_index(self, index_name: str, settings: Mapping[str, object]) -> None:
         """
@@ -549,9 +556,24 @@ class MeilisearchBackend:
         if task_uid is None:
             return
         if hasattr(self._client, "wait_for_task"):
-            result = cast(_MeilisearchClientWithWait, self._client).wait_for_task(
-                task_uid
-            )
+            wait_for_task = cast(_MeilisearchClientWithWait, self._client).wait_for_task
+            supports_timeout = True
+            try:
+                wait_signature = signature(wait_for_task)
+            except (TypeError, ValueError):
+                # Uninspectable clients retain the standard Meilisearch call.
+                pass
+            else:
+                try:
+                    wait_signature.bind(
+                        task_uid, timeout_in_ms=self._task_timeout_in_ms
+                    )
+                except TypeError:
+                    supports_timeout = False
+            if supports_timeout:
+                result = wait_for_task(task_uid, timeout_in_ms=self._task_timeout_in_ms)
+            else:
+                result = cast(Callable[[object], object], wait_for_task)(task_uid)
             self._raise_for_failed_task(result)
             return
         if hasattr(self._client, "get_task"):