GeneralManager 0.59.2__tar.gz → 0.59.3__tar.gz

{generalmanager-0.59.2/src/GeneralManager.egg-info → generalmanager-0.59.3}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.59.2
+Version: 0.59.3
 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.59.2 → generalmanager-0.59.3}/src/general_manager/cache/cache_tracker.py

@@ -142,6 +142,11 @@ class DependencyTracker:
         ]:
             dep_set.add((class_name, operation, identifier))
 
+    @staticmethod
+    def is_active() -> bool:
+        """Return whether dependency tracking is active for this execution context."""
+        return _dependency_storage.depth >= 0
+
     @staticmethod
     def reset_thread_local_storage() -> None:
         """Clear all dependency tracking data for the current thread.

{generalmanager-0.59.2 → generalmanager-0.59.3}/src/general_manager/cache/dependency_matching.py

@@ -101,6 +101,12 @@ def normalize_dependency_value(value: object) -> NormalizedDependencyValue:
 
 def serialize_normalized_value(value: object) -> str:
     """Serialize dependency values in the canonical dependency format."""
+    if isinstance(value, str):
+        return json.dumps(value)
+    if value is None or isinstance(value, (int, float, bool)):
+        return json.dumps(value)
+    if isinstance(value, date):
+        return json.dumps(value.isoformat())
     return json.dumps(normalize_dependency_value(value), sort_keys=True)
 
 

{generalmanager-0.59.2 → generalmanager-0.59.3}/src/general_manager/interface/base_interface.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 from abc import ABC
+from collections.abc import Mapping
+from dataclasses import dataclass
 import inspect
+from types import MappingProxyType
 from typing import (
     Type,
     TYPE_CHECKING,
@@ -190,12 +193,25 @@ def _should_validate_possible_values() -> bool:
     return bool(settings.DEBUG)
 
 
+@dataclass(frozen=True, slots=True)
+class _InputParsingPlan:
+    names: tuple[str, ...]
+    name_set: frozenset[str]
+    alias_to_name: Mapping[str, str]
+    required_names: frozenset[str]
+    optional_names: frozenset[str]
+    dependency_items: tuple[tuple[str, tuple[str, ...]], ...]
+    field_state: tuple[tuple[str, int, bool, tuple[str, ...]], ...]
+
+
 class InterfaceBase(ABC):
     """Common base API for interfaces backing GeneralManager classes."""
 
     _parent_class: ClassVar[Type["GeneralManager"]]
     _interface_type: ClassVar[str]
     input_fields: ClassVar[dict[str, "Input[type[object]]"]]
+    _input_parsing_plan: ClassVar[_InputParsingPlan | None] = None
+    _input_dependency_order: ClassVar[tuple[str, ...] | None] = None
     lifecycle_capability_name: ClassVar[CapabilityName | None] = None
     _capabilities: ClassVar[frozenset[CapabilityName]] = frozenset()
     _capability_selection: ClassVar["CapabilitySelection | None"] = None
@@ -212,6 +228,8 @@ class InterfaceBase(ABC):
         This method resets per-subclass capability registries and configuration to a clean default, merges configured capability overrides into the class's capability_overrides mapping, and clears the flag that marks configured capabilities as applied. Keyword arguments are forwarded to the superclass implementation.
         """
         super().__init_subclass__(**kwargs)
+        cls._input_parsing_plan = None
+        cls._input_dependency_order = None
         cls._capabilities = frozenset()
         cls._capability_selection = None
         cls._capability_handlers = {}
@@ -564,6 +582,89 @@ class InterfaceBase(ABC):
             if callable(hook):
                 register_system_check(cls, hook)
 
+    @classmethod
+    def _get_input_parsing_plan(cls) -> _InputParsingPlan:
+        plan = cls._input_parsing_plan
+        if plan is not None:
+            if cls._input_parsing_plan_is_fresh(plan):
+                return plan
+            cls._input_dependency_order = None
+
+        names = tuple(cls.input_fields.keys())
+        field_items = tuple(cls.input_fields.items())
+        name_set = frozenset(names)
+        alias_to_name = MappingProxyType({f"{name}_id": name for name in names})
+        required_names = frozenset(
+            name for name, input_field in field_items if input_field.required
+        )
+        optional_names = name_set - required_names
+        dependency_items = tuple(
+            (name, tuple(input_field.depends_on)) for name, input_field in field_items
+        )
+        field_state = tuple(
+            (name, id(input_field), input_field.required, tuple(input_field.depends_on))
+            for name, input_field in field_items
+        )
+
+        plan = _InputParsingPlan(
+            names=names,
+            name_set=name_set,
+            alias_to_name=alias_to_name,
+            required_names=required_names,
+            optional_names=optional_names,
+            dependency_items=dependency_items,
+            field_state=field_state,
+        )
+        cls._input_parsing_plan = plan
+        return plan
+
+    @classmethod
+    def _input_parsing_plan_is_fresh(cls, plan: _InputParsingPlan) -> bool:
+        if len(cls.input_fields) != len(plan.field_state):
+            return False
+        if tuple(cls.input_fields) != plan.names:
+            return False
+        for name, input_id, required, depends_on in plan.field_state:
+            input_field = cls.input_fields.get(name)
+            if input_field is None:
+                return False
+            if id(input_field) != input_id:
+                return False
+            if input_field.required != required:
+                return False
+            if tuple(input_field.depends_on) != depends_on:
+                return False
+        return True
+
+    @classmethod
+    def _get_input_dependency_order(
+        cls,
+        plan: _InputParsingPlan,
+    ) -> tuple[tuple[str, ...], frozenset[str]]:
+        ordered_names = cls._input_dependency_order
+        if ordered_names is not None:
+            return ordered_names, frozenset()
+
+        ordered: list[str] = []
+        processed: set[str] = set()
+        while len(processed) < len(plan.names):
+            progress_made = False
+            for name, depends_on in plan.dependency_items:
+                if name in processed:
+                    continue
+                if all(dependency in processed for dependency in depends_on):
+                    ordered.append(name)
+                    processed.add(name)
+                    progress_made = True
+            if not progress_made:
+                break
+
+        ordered_names = tuple(ordered)
+        unresolved = frozenset(plan.name_set - processed)
+        if not unresolved:
+            cls._input_dependency_order = ordered_names
+        return ordered_names, unresolved
+
     def parse_input_fields_to_identification(
         self,
         *args: object,
@@ -573,10 +674,10 @@ class InterfaceBase(ABC):
         Convert positional and keyword inputs into a validated identification mapping for the interface's input fields.
 
         Positional values are assigned in `input_fields` declaration order before
-        keyword validation. A keyword named `<field>_id` is accepted only when
-        `<field>` is a declared input and the canonical field name was not
-        already supplied. Positional overflow, duplicate positional-plus-keyword
-        values, alias collisions, and unknown aliases surface as
+        keyword validation. A keyword named `<field>_id` is accepted when
+        `<field>` is a declared input; if both are supplied, the `_id` alias
+        overwrites the canonical value. Positional overflow,
+        duplicate positional-plus-keyword values, and unknown aliases surface as
         `UnexpectedInputArgumentsError` through the argument-normalization path.
 
         Parameters:
@@ -596,62 +697,44 @@ class InterfaceBase(ABC):
             InvalidPossibleValuesTypeError: If an input's `possible_values` configuration is neither callable nor iterable.
             InvalidInputValueError: If a provided value is not in the allowed set defined by an input's `possible_values`.
         """
-        identification: dict[str, object] = {}
-        kwargs = args_to_kwargs(args, self.input_fields.keys(), kwargs)
-        # Check for extra arguments
-        extra_args = set(kwargs.keys()) - set(self.input_fields.keys())
+        resolved_identification: dict[str, object] = {}
+        plan = type(self)._get_input_parsing_plan()
+        kwargs = args_to_kwargs(args, plan.names, kwargs)
+
+        extra_args = set(kwargs) - plan.name_set
         if extra_args:
             handled: set[str] = set()
             for extra_arg in list(extra_args):
-                if extra_arg.endswith("_id"):
-                    base = extra_arg[:-3]
-                    if base in self.input_fields:
-                        kwargs[base] = kwargs.pop(extra_arg)
-                        handled.add(extra_arg)
-            # recompute remaining unknown keys after handling known *_id aliases
-            remaining = (extra_args - handled) | (
-                set(kwargs.keys()) - set(self.input_fields.keys())
-            )
+                alias = plan.alias_to_name.get(extra_arg)
+                if alias is not None:
+                    kwargs[alias] = kwargs.pop(extra_arg)
+                    handled.add(extra_arg)
+            remaining = (extra_args - handled) | (set(kwargs) - plan.name_set)
             if remaining:
                 raise UnexpectedInputArgumentsError(remaining)
 
-        for name, input_field in self.input_fields.items():
-            if name not in kwargs and not input_field.required:
+        for name in plan.optional_names:
+            if name not in kwargs:
                 kwargs[name] = None
 
-        missing_args = {
-            name
-            for name, input_field in self.input_fields.items()
-            if input_field.required and name not in kwargs
-        }
+        missing_args = plan.required_names - set(kwargs)
         if missing_args:
             raise MissingInputArgumentsError(missing_args)
 
-        # process input fields with dependencies
-        processed: set[str] = set()
-        while len(processed) < len(self.input_fields):
-            progress_made = False
-            for name, input_field in self.input_fields.items():
-                if name in processed:
-                    continue
-                depends_on = input_field.depends_on
-                if all(dep in processed for dep in depends_on):
-                    cache_context = type(self)._input_possible_values_cache_context(
-                        name
-                    )
-                    value = self.input_fields[name].cast(
-                        kwargs.get(name),
-                        identification,
-                        cache_context=cache_context,
-                    )
-                    self._process_input(name, value, identification)
-                    identification[name] = value
-                    processed.add(name)
-                    progress_made = True
-            if not progress_made:
-                # detect circular dependencies
-                unresolved = set(self.input_fields.keys()) - processed
-                raise CircularInputDependencyError(unresolved)
+        ordered_names, unresolved = type(self)._get_input_dependency_order(plan)
+        for name in ordered_names:
+            input_field = self.input_fields[name]
+            cache_context = type(self)._input_possible_values_cache_context(name)
+            value = input_field.cast(
+                kwargs.get(name),
+                resolved_identification,
+                cache_context=cache_context,
+            )
+            self._process_input(name, value, resolved_identification)
+            resolved_identification[name] = value
+        if unresolved:
+            raise CircularInputDependencyError(unresolved)
+        identification = {name: resolved_identification[name] for name in plan.names}
         return identification
 
     @classmethod

{generalmanager-0.59.2 → generalmanager-0.59.3}/src/general_manager/interface/capabilities/core/observability.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from collections.abc import Mapping
 from typing import ClassVar, Protocol
 
@@ -54,6 +55,12 @@ class LoggingObservabilityCapability(BaseCapability):
         """
         self._logger = get_logger("interface.observability")
 
+    def _debug_enabled(self) -> bool:
+        is_enabled_for = getattr(self._logger, "isEnabledFor", None)
+        if callable(is_enabled_for):
+            return bool(is_enabled_for(logging.DEBUG))
+        return True
+
     def before_operation(
         self,
         *,
@@ -64,13 +71,14 @@ class LoggingObservabilityCapability(BaseCapability):
         """
         Log the start of an interface operation with contextual metadata.
 
-        Calls ``self._logger.debug("interface operation start", context=...)``.
-        The context contains ``operation``, a string ``target`` name,
+        When debug logging is enabled, calls
+        ``self._logger.debug("interface operation start", context=...)``. The
+        context contains ``operation``, a string ``target`` name,
         ``payload_keys`` sorted from the payload keys, and selected payload
         metadata values: ``service``, ``method``, ``path``, ``status_code``,
-        ``retry_count``, and ``request_id``. Selected metadata keys are included
-        whenever they are present in the payload, including when their value is
-        ``None``.
+        ``retry_count``, and ``request_id``. Selected metadata keys are
+        included whenever they are present in the payload, including when their
+        value is ``None``.
 
         Parameters:
             operation: Operation name recorded unchanged.
@@ -80,9 +88,13 @@ class LoggingObservabilityCapability(BaseCapability):
                 metadata keys listed above.
 
         Raises:
-            Exception: Target-name lookup, payload-key sorting, payload metadata
-                lookup, and logger errors propagate unchanged.
+            Exception: Logger debug-enabled checks propagate unchanged. When
+                debug logging is enabled, target-name lookup, payload-key
+                sorting, payload metadata lookup, and logger errors propagate
+                unchanged.
         """
+        if not self._debug_enabled():
+            return
         self._logger.debug(
             "interface operation start",
             context=self._context(operation, target, payload),
@@ -99,16 +111,16 @@ class LoggingObservabilityCapability(BaseCapability):
         """
         Record the end of an interface operation.
 
-        Calls ``self._logger.debug("interface operation end", context=...)``.
-        The context starts with the same fields as ``before_operation()`` and
-        adds ``result_type`` as ``type(result).__name__``. If
-        ``result.metadata`` is a mapping, ``status_code``, ``retry_count``, and
-        ``request_id`` from that ``collections.abc.Mapping`` replace same-named
-        payload metadata values in the end-event context. Result metadata keys
-        are included whenever they are present in the mapping, including when
-        their value is ``None``. A missing ``metadata`` attribute, an
-        ``AttributeError`` raised while reading ``metadata``, or a non-mapping
-        metadata value is ignored.
+        When debug logging is enabled, calls
+        ``self._logger.debug("interface operation end", context=...)``. The
+        context starts with the same fields as ``before_operation()`` and adds
+        ``result_type`` as ``type(result).__name__``. If ``result.metadata`` is
+        a mapping, ``status_code``, ``retry_count``, and ``request_id`` from
+        that ``collections.abc.Mapping`` replace same-named payload metadata
+        values in the end-event context. Result metadata keys are included
+        whenever they are present in the mapping, including when their value is
+        ``None``. A missing ``metadata`` attribute, an ``AttributeError`` raised
+        while reading ``metadata``, or a non-mapping metadata value is ignored.
 
         Parameters:
             operation: Operation name recorded unchanged.
@@ -119,10 +131,14 @@ class LoggingObservabilityCapability(BaseCapability):
                 metadata are recorded.
 
         Raises:
-            Exception: Target-name lookup, payload-key sorting, payload metadata
-                lookup, non-``AttributeError`` result metadata lookup failures,
-                and logger errors propagate unchanged.
+            Exception: Logger debug-enabled checks propagate unchanged. When
+                debug logging is enabled, target-name lookup, payload-key
+                sorting, payload metadata lookup, non-``AttributeError`` result
+                metadata lookup failures, and logger errors propagate
+                unchanged.
         """
+        if not self._debug_enabled():
+            return
         context = self._context(operation, target, payload)
         result_metadata = getattr(result, "metadata", None)
         if isinstance(result_metadata, Mapping):

{generalmanager-0.59.2 → generalmanager-0.59.3}/src/general_manager/manager/general_manager.py

@@ -75,11 +75,12 @@ class GeneralManager(metaclass=GeneralManagerMeta):
         self.__id: dict[str, object] = self._interface.identification
         self._manager_state_valid = True
         self._manager_state_reason = None
-        DependencyTracker.track(
-            self.__class__.__name__,
-            "identification",
-            serialize_dependency_identifier(self.__id),
-        )
+        if DependencyTracker.is_active():
+            DependencyTracker.track(
+                self.__class__.__name__,
+                "identification",
+                serialize_dependency_identifier(self.__id),
+            )
         logger.debug(
             "instantiated manager",
             context={
@@ -127,11 +128,12 @@ class GeneralManager(metaclass=GeneralManagerMeta):
         manager.__id = manager._interface.identification
         manager._manager_state_valid = True
         manager._manager_state_reason = None
-        DependencyTracker.track(
-            cls.__name__,
-            "identification",
-            serialize_dependency_identifier(manager.__id),
-        )
+        if DependencyTracker.is_active():
+            DependencyTracker.track(
+                cls.__name__,
+                "identification",
+                serialize_dependency_identifier(manager.__id),
+            )
         logger.debug(
             "trusted orm manager hydrated",
             context={

{generalmanager-0.59.2 → generalmanager-0.59.3}/src/general_manager/manager/meta.py

@@ -127,10 +127,15 @@ class GeneralManagerMeta(type):
         ``__getattr__`` is only reached for missing names, so inherited
         ``GeneralManager`` attributes must pass through here to let declared
         fields override inherited names the same way bootstrap initialization
-        does. "Non-private" means the requested name does not start with
-        ``"_"`` and is not exactly ``"Interface"``. Probing an unknown public
-        name may call ``Interface.get_attributes()``, but it installs
-        descriptors only when the probed name is declared by the interface.
+        does. Once a manager class has completed descriptor initialization,
+        attributes already present on that class use normal type lookup without
+        rechecking initialization. Missing names and inherited public names
+        still pass through initialization so late-discovered fields keep the
+        existing override behavior. "Non-private" means the requested name does
+        not start with ``"_"`` and is not exactly ``"Interface"``. Probing an
+        unknown public name may call ``Interface.get_attributes()``, but it
+        installs descriptors only when the probed name is declared by the
+        interface.
 
         Parameters:
             attribute_name: Class attribute being read.
@@ -145,6 +150,10 @@ class GeneralManagerMeta(type):
                 ``NotImplementedError`` propagate unchanged.
         """
         if not attribute_name.startswith("_") and attribute_name != "Interface":
+            class_dict = type.__getattribute__(cls, "__dict__")
+            initialized = class_dict.get("_gm_attributes_initialized", False)
+            if initialized and attribute_name in class_dict:
+                return type.__getattribute__(cls, attribute_name)
             manager_class = cast(type["GeneralManager"], cls)
             GeneralManagerMeta.ensure_attributes_initialized(
                 manager_class, attribute_name
@@ -234,6 +243,7 @@ class GeneralManagerMeta(type):
                     GeneralManagerMeta.create_at_properties_for_attributes(
                         attributes.keys(), manager_class
                     )
+                type.__setattr__(manager_class, "_gm_attributes_initialized", True)
                 return True
 
             try:
@@ -246,6 +256,7 @@ class GeneralManagerMeta(type):
             GeneralManagerMeta.create_at_properties_for_attributes(
                 attributes.keys(), manager_class
             )
+            type.__setattr__(manager_class, "_gm_attributes_initialized", True)
             try:
                 GeneralManagerMeta.pending_attribute_initialization.remove(
                     manager_class
@@ -509,6 +520,7 @@ class GeneralManagerMeta(type):
 
         for attr_name in attributes:
             setattr(new_class, attr_name, descriptor_method(attr_name, new_class))
+        type.__setattr__(new_class, "_gm_attributes_initialized", True)
 
 
 _CAPABILITY_BUILDER: "ManifestCapabilityBuilder | None" = None

{generalmanager-0.59.2 → generalmanager-0.59.3}/src/general_manager/measurement/measurement.py

@@ -3,6 +3,7 @@
 # units.py
 from __future__ import annotations
 from collections.abc import Callable
+from functools import lru_cache
 from typing import TypeAlias, TypeGuard, cast
 import pint
 from decimal import Decimal, getcontext, InvalidOperation
@@ -63,21 +64,43 @@ def _is_numeric_scalar(value: object) -> TypeGuard[NumericScalar]:
     return not isinstance(value, bool) and isinstance(value, (Decimal, float, int))
 
 
-def _unit_uses_offset(unit: str | pint.Unit | MeasurementQuantity) -> bool:
-    """Return whether a Pint unit has offset conversion semantics."""
+@lru_cache(maxsize=256)
+def _unit_uses_offset_for_unit_string(unit: str) -> bool:
+    """Return whether a unit string has offset conversion semantics."""
 
-    parsed_unit = ureg.parse_units(
-        str(unit.units if isinstance(unit, PlainQuantity) else unit)
-    )
-    for unit_name, power in parsed_unit._units.items():
+    for unit_name, power in _pint_unit_components(unit):
         if power != 1:
             continue
-        converter = ureg._units[unit_name].converter
-        if getattr(converter, "offset", None) is not None:
+        if _pint_unit_component_uses_offset(unit_name):
             return True
     return False
 
 
+def _pint_unit_components(unit: str) -> tuple[tuple[str, object], ...]:
+    """Return Pint unit component names and powers for one unit expression."""
+
+    parsed_unit = ureg.parse_units(unit)
+    return tuple(parsed_unit._units.items())
+
+
+def _pint_unit_component_uses_offset(unit_name: str) -> bool:
+    """Return whether a Pint unit component has offset conversion semantics."""
+
+    converter = ureg._units[unit_name].converter
+    return getattr(converter, "offset", None) is not None
+
+
+def _unit_uses_offset(unit: str | pint.Unit | MeasurementQuantity) -> bool:
+    """Return whether a Pint unit has offset conversion semantics."""
+
+    unit_string = str(unit.units if isinstance(unit, PlainQuantity) else unit)
+    return _unit_uses_offset_for_unit_string(unit_string)
+
+
+_unit_uses_offset.cache_clear = _unit_uses_offset_for_unit_string.cache_clear  # type: ignore[attr-defined]
+_unit_uses_offset.cache_info = _unit_uses_offset_for_unit_string.cache_info  # type: ignore[attr-defined]
+
+
 def _quantity_as_float(quantity: MeasurementQuantity) -> PlainQuantity[float]:
     """Rebuild a quantity with a float magnitude so offset-unit math stays in Pint."""