GeneralManager 0.60.3__tar.gz → 0.60.5__tar.gz

{generalmanager-0.60.3/src/GeneralManager.egg-info → generalmanager-0.60.5}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.60.3
+Version: 0.60.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.60.3 → generalmanager-0.60.5}/src/general_manager/chat/system_prompt.py

@@ -255,16 +255,21 @@ def _relationship_lines(
     index: dict[str, dict[str, object]], manager_names: list[str]
 ) -> list[str]:
     relationship_lines: list[str] = []
-    if not PathMap.mapping and manager_names:
-        PathMap(manager_names[0])
-    for (from_manager, to_manager), tracer in sorted(PathMap.mapping.items()):
-        if from_manager not in index or to_manager not in index:
-            continue
-        path = getattr(tracer, "path", None)
-        if path:
-            relationship_lines.append(
-                f"{from_manager} -> {to_manager}: {' -> '.join(path)}"
-            )
+    exposed_names = [name for name in manager_names if name in index]
+    if len(exposed_names) > PROMPT_MANAGER_DETAIL_LIMIT:
+        # Bound lazy path resolution to avoid reintroducing CPU-bound O(n^2) work.
+        return relationship_lines
+    for from_manager in exposed_names:
+        path_map = PathMap(from_manager)
+        for to_manager in exposed_names:
+            if from_manager == to_manager:
+                continue
+            tracer = path_map.to(to_manager)
+            path = getattr(tracer, "path", None) if tracer is not None else None
+            if path:
+                relationship_lines.append(
+                    f"{from_manager} -> {to_manager}: {' -> '.join(path)}"
+                )
     return relationship_lines
 
 

{generalmanager-0.60.3 → generalmanager-0.60.5}/src/general_manager/measurement/measurement.py

@@ -91,6 +91,7 @@ def _unit_uses_offset_for_unit_string(unit: str) -> bool:
     return False
 
 
+@lru_cache(maxsize=512)
 def _pint_unit_components(unit: str) -> tuple[tuple[str, object], ...]:
     """Return Pint unit component names and powers for one unit expression."""
 
@@ -98,6 +99,13 @@ def _pint_unit_components(unit: str) -> tuple[tuple[str, object], ...]:
     return tuple(parsed_unit._units.items())
 
 
+@lru_cache(maxsize=512)
+def _unit_dimensionality(unit: str) -> object:
+    """Return Pint dimensionality metadata for one unit expression."""
+
+    return _parse_unit(unit).dimensionality
+
+
 def _pint_unit_component_uses_offset(unit_name: str) -> bool:
     """Return whether a Pint unit component has offset conversion semantics."""
 
@@ -187,12 +195,12 @@ def _convert_quantity(
     return source_quantity.to(target_unit)
 
 
+@lru_cache(maxsize=512)
 def _currency_component(unit: str) -> tuple[str, int] | None:
     """Return the single configured currency component in a unit expression."""
 
-    parsed_unit = ureg.parse_units(str(unit))
     currency_components: list[tuple[str, int]] = []
-    for unit_name, power in parsed_unit._units.items():
+    for unit_name, power in _pint_unit_components(unit):
         currency_power = _integer_unit_power(power)
         if currency_power is not None and unit_name in currency_units:
             currency_components.append((unit_name, currency_power))
@@ -213,13 +221,69 @@ def _integer_unit_power(power: object) -> int | None:
     return None
 
 
+@lru_cache(maxsize=512)
 def _unit_without_currency(unit: str, currency: str, power: int) -> str:
     """Return a unit expression with one currency component removed."""
 
-    stripped_unit = ureg.parse_units(str(unit)) / (ureg.parse_units(currency) ** power)
+    stripped_unit = _parse_unit(unit) / (_parse_unit(currency) ** power)
     return str(stripped_unit)
 
 
+def _is_implicit_cross_currency_conversion(
+    source_unit: str,
+    target_unit: str,
+) -> bool:
+    """Return whether a conversion would require an explicit exchange rate."""
+
+    source_currency = _currency_component(source_unit)
+    target_currency = _currency_component(target_unit)
+    return (
+        source_currency is not None
+        and target_currency is not None
+        and source_currency[0] != target_currency[0]
+    )
+
+
+@lru_cache(maxsize=1024)
+def _multiplicative_conversion_factor(
+    source_unit: str,
+    target_unit: str,
+) -> Decimal | None:
+    """Return a cached Decimal factor for safe multiplicative conversions."""
+
+    try:
+        if (
+            _unit_uses_offset_for_unit_string(source_unit)
+            or _unit_uses_offset_for_unit_string(target_unit)
+            or _is_implicit_cross_currency_conversion(source_unit, target_unit)
+        ):
+            return None
+        converted_quantity = ureg.Quantity(
+            Decimal("1"),
+            _parse_unit(source_unit),
+        ).to(_parse_unit(target_unit))
+    except pint.errors.PintError:
+        return None
+    return _decimal_from_magnitude(converted_quantity.magnitude)
+
+
+def _cached_multiplicative_conversion_factor(
+    source_unit: str,
+    target_unit: str,
+) -> Decimal | None:
+    """Return a cached factor keyed by canonical source and target units."""
+
+    try:
+        source_canonical_unit = _canonical_unit_string(source_unit)
+        target_canonical_unit = _canonical_unit_string(target_unit)
+    except pint.errors.PintError:
+        return None
+    return _multiplicative_conversion_factor(
+        source_canonical_unit,
+        target_canonical_unit,
+    )
+
+
 def convert_magnitude(value: Decimal, source_unit: str, target_unit: str) -> Decimal:
     """
     Convert a magnitude between units while keeping offset-unit math away from Decimal.
@@ -230,6 +294,13 @@ def convert_magnitude(value: Decimal, source_unit: str, target_unit: str) -> Dec
     round-trip back to ``Decimal`` via ``str``.
     """
 
+    conversion_factor = _cached_multiplicative_conversion_factor(
+        source_unit,
+        target_unit,
+    )
+    if conversion_factor is not None:
+        return _decimal_from_magnitude(value * conversion_factor)
+
     converted_quantity = _convert_quantity(
         _build_quantity(value, source_unit), target_unit
     )
@@ -830,10 +901,10 @@ class Measurement:
             )
         elif not self.is_currency() and not other.is_currency():
             # Both are physical units
+            if _unit_dimensionality(left_unit) != _unit_dimensionality(right_unit):
+                raise IncompatibleUnitsError("addition")
             left_quantity = self.__current_quantity()
             right_quantity = other.__current_quantity()
-            if left_quantity.dimensionality != right_quantity.dimensionality:
-                raise IncompatibleUnitsError("addition")
             left_quantity, right_quantity = _prepare_quantities_for_binary_operation(
                 left_quantity,
                 right_quantity,
@@ -883,10 +954,10 @@ class Measurement:
             return Measurement(Decimal(str(result_quantity.magnitude)), str(self.unit))
         elif not self.is_currency() and not other.is_currency():
             # Both are physical units
+            if _unit_dimensionality(left_unit) != _unit_dimensionality(right_unit):
+                raise IncompatibleUnitsError("subtraction")
             left_quantity = self.__current_quantity()
             right_quantity = other.__current_quantity()
-            if left_quantity.dimensionality != right_quantity.dimensionality:
-                raise IncompatibleUnitsError("subtraction")
             left_quantity, right_quantity = _prepare_quantities_for_binary_operation(
                 left_quantity,
                 right_quantity,

{generalmanager-0.60.3 → generalmanager-0.60.5}/src/general_manager/utils/path_mapping.py

@@ -1,6 +1,7 @@
 """Utilities for tracing relationships between GeneralManager classes."""
 
 from __future__ import annotations
+from collections import deque
 from collections.abc import Mapping
 from typing import ClassVar, cast, get_args
 from general_manager.manager.meta import GeneralManagerMeta
@@ -12,6 +13,8 @@ from general_manager.manager.general_manager import GeneralManager
 
 type PathStart = str
 type PathDestination = str
+type PathEdge = tuple[str, PathDestination]
+type PathClassEdge = tuple[str, type[GeneralManager]]
 type TraversalValue = GeneralManager | Bucket[GeneralManager]
 
 
@@ -36,47 +39,196 @@ class InvalidPathTraversalValueError(TypeError):
         )
 
 
+def _as_manager_class(value: object) -> type[GeneralManager] | None:
+    """Return value when it is a GeneralManager subclass."""
+    if value is None or not isinstance(value, type):
+        return None
+    if not issubclass(value, GeneralManager):
+        return None
+    return value
+
+
+def _iter_manager_connections(
+    manager_class: type[GeneralManager],
+) -> list[tuple[str, type[GeneralManager]]]:
+    """Return traversable manager edges declared by interface fields and GraphQL properties."""
+    current_connections: dict[str, object] = {}
+    for attr_name, attr_value in manager_class.Interface.get_attribute_types().items():
+        if isinstance(attr_value, Mapping):
+            current_connections[attr_name] = attr_value.get("type")
+    seen_attrs: set[str] = set()
+    for mro_class in manager_class.__mro__:
+        for attr_name, attr_value in mro_class.__dict__.items():
+            if attr_name in seen_attrs:
+                continue
+            seen_attrs.add(attr_name)
+            if not isinstance(attr_value, GraphQLProperty):
+                continue
+            type_hints = get_args(attr_value.graphql_type_hint)
+            field_type = (
+                type_hints[0]
+                if type_hints
+                else cast(type[object], attr_value.graphql_type_hint)
+            )
+            current_connections[attr_name] = field_type
+
+    connections: list[tuple[str, type[GeneralManager]]] = []
+    for attr_name, attr_type in current_connections.items():
+        manager_type = _as_manager_class(attr_type)
+        if manager_type is not None:
+            connections.append((attr_name, manager_type))
+    return connections
+
+
 class PathMap:
     """
     Maintain cached traversal paths between GeneralManager classes.
 
-    The class-level mapping stores one PathTracer for each registered
-    start/destination class-name pair. A cached tracer may have ``path is None``
-    when the classes are known but no route exists.
+    The class-level mapping stores lazily resolved PathTracer objects for
+    requested start/destination class-name pairs. A cached tracer may have
+    ``path is None`` when the classes are known but no route exists.
     """
 
     instance: PathMap
     mapping: ClassVar[dict[tuple[PathStart, PathDestination], PathTracer]] = {}
+    _registry_signature: ClassVar[tuple[type[GeneralManager], ...]] = ()
+    _classes_by_name: ClassVar[dict[str, type[GeneralManager]]] = {}
+    _adjacency: ClassVar[dict[PathStart, tuple[PathEdge, ...]]] = {}
+    _class_adjacency: ClassVar[
+        dict[type[GeneralManager], tuple[PathClassEdge, ...]]
+    ] = {}
 
     def __new__(cls, *args: object, **kwargs: object) -> PathMap:
         """
-        Obtain the singleton PathMap, initializing the path mapping on first instantiation.
+        Obtain the singleton PathMap, refreshing graph metadata on each construction.
 
         Returns:
             PathMap: The singleton PathMap instance.
         """
+        force_refresh = False
         if not hasattr(cls, "instance"):
             cls.instance = super().__new__(cls)
-            cls.create_path_mapping()
+            force_refresh = not cls.mapping
+        cls._ensure_graph_current(force=force_refresh)
         return cls.instance
 
     @classmethod
     def create_path_mapping(cls) -> None:
         """
-        Populate the path mapping with tracers for every distinct pair of managed classes.
-
-        The generated tracers capture the attribute sequence needed to navigate from the start class to the destination class and are cached on the singleton instance.
+        Refresh path graph metadata without eagerly creating all pair tracers.
 
         Returns:
             None
         """
-        all_managed_classes = GeneralManagerMeta.all_classes
-        for start_class in all_managed_classes:
-            for destination_class in all_managed_classes:
-                if start_class != destination_class:
-                    cls.instance.mapping[
-                        (start_class.__name__, destination_class.__name__)
-                    ] = PathTracer(start_class, destination_class)
+        cls._ensure_graph_current(force=True)
+
+    @classmethod
+    def _ensure_graph_current(cls, *, force: bool = False) -> None:
+        """Refresh class and adjacency caches when the manager registry changes."""
+        registry_signature = tuple(GeneralManagerMeta.all_classes)
+        if not force and cls._registry_signature == registry_signature:
+            return
+
+        cls._registry_signature = registry_signature
+        cls._classes_by_name = {
+            manager_class.__name__: manager_class
+            for manager_class in registry_signature
+        }
+        cls._class_adjacency = {
+            manager_class: tuple(_iter_manager_connections(manager_class))
+            for manager_class in registry_signature
+        }
+        cls._adjacency = {
+            manager_class.__name__: tuple(
+                (attr, target_class.__name__)
+                for attr, target_class in cls._class_adjacency[manager_class]
+            )
+            for manager_class in registry_signature
+        }
+        cls.mapping.clear()
+
+    @classmethod
+    def _edges_for_class(
+        cls,
+        manager_class: type[GeneralManager],
+    ) -> tuple[PathClassEdge, ...]:
+        """Return cached outgoing edges for registered or discovered manager classes."""
+        edges = cls._class_adjacency.get(manager_class)
+        if edges is not None:
+            return edges
+
+        edges = tuple(_iter_manager_connections(manager_class))
+        cls._class_adjacency[manager_class] = edges
+        cls._adjacency.setdefault(
+            manager_class.__name__,
+            tuple((attr, target_class.__name__) for attr, target_class in edges),
+        )
+        return edges
+
+    @classmethod
+    def _find_path(
+        cls,
+        start_class_name: PathStart,
+        destination_class_name: PathDestination,
+    ) -> list[str] | None:
+        """Find the shortest attribute path between two registered managers."""
+        if start_class_name == destination_class_name:
+            return []
+
+        start_class = cls._classes_by_name.get(start_class_name)
+        destination_class = cls._classes_by_name.get(destination_class_name)
+        if start_class is None or destination_class is None:
+            return None
+
+        visited = {start_class}
+        queue: deque[tuple[type[GeneralManager], list[str]]] = deque(
+            [(start_class, [])]
+        )
+
+        while queue:
+            current_class, current_path = queue.popleft()
+            for attr, next_class in cls._edges_for_class(current_class):
+                if next_class in visited:
+                    continue
+                next_path = [*current_path, attr]
+                if next_class == destination_class:
+                    return next_path
+                visited.add(next_class)
+                queue.append((next_class, next_path))
+
+        return None
+
+    @staticmethod
+    def _destination_name(
+        path_destination: PathDestination | type[GeneralManager] | str,
+    ) -> PathDestination:
+        """Return the class-name key for a path destination input."""
+        if isinstance(path_destination, type):
+            return path_destination.__name__
+        return path_destination
+
+    def _get_or_create_tracer(
+        self,
+        destination_class_name: PathDestination,
+    ) -> PathTracer | None:
+        """Return the cached tracer for one pair, computing only that pair when needed."""
+        if self.start_class_name == destination_class_name:
+            return None
+
+        key = (self.start_class_name, destination_class_name)
+        tracer = self.mapping.get(key)
+        if tracer is not None:
+            return tracer
+
+        start_class = self._classes_by_name.get(self.start_class_name)
+        destination_class = self._classes_by_name.get(destination_class_name)
+        if start_class is None or destination_class is None:
+            return None
+
+        path = self._find_path(self.start_class_name, destination_class_name)
+        tracer = PathTracer(start_class, destination_class, path, search=False)
+        self.mapping[key] = tracer
+        return tracer
 
     def __init__(
         self,
@@ -113,23 +265,18 @@ class PathMap:
         """
         Retrieve the cached path tracer from the start class to the desired destination.
 
-        ``None`` means no cached key exists for the start/destination names. A
-        non-``None`` tracer can still be unreachable; inspect ``tracer.path`` for
-        ``None`` before treating it as a usable route.
+        ``None`` means either the start or destination class name is not
+        registered, or the requested pair uses the same start and destination
+        class. A non-``None`` tracer can still be unreachable; inspect
+        ``tracer.path`` for ``None`` before treating it as a usable route.
 
         Parameters:
             path_destination (PathDestination | type[GeneralManager] | str): Target manager identifier, either as a manager class or string class name. Destination instances are not accepted.
 
         Returns:
-            PathTracer | None: The cached tracer for the registered class-name pair, or None when no mapping key exists.
+            PathTracer | None: The cached tracer for the registered class-name pair, or None when no mapping key can be created.
         """
-        if isinstance(path_destination, type):
-            path_destination = path_destination.__name__
-
-        tracer = self.mapping.get((self.start_class_name, path_destination), None)
-        if not tracer:
-            return None
-        return tracer
+        return self._get_or_create_tracer(self._destination_name(path_destination))
 
     def go_to(
         self, path_destination: PathDestination | type[GeneralManager] | str
@@ -137,11 +284,11 @@ class PathMap:
         """
         Traverse the cached path from the configured start to the given destination.
 
-        The lookup first resolves a cached tracer. Missing tracer keys and
-        tracers with ``path is None`` return ``None``. A tracer with an empty
-        path also returns ``None`` because no traversal is required. If a
-        traversable path exists but this PathMap was created from a class or
-        string start, MissingStartInstanceError is raised.
+        The lookup lazily resolves and caches the requested tracer. Missing
+        tracer keys and tracers with ``path is None`` return ``None``. A tracer
+        with an empty path also returns ``None`` because no traversal is
+        required. If a traversable path exists but this PathMap was created from
+        a class or string start, MissingStartInstanceError is raised.
 
         Parameters:
             path_destination (PathDestination | type[GeneralManager] | str): Destination specified as a manager class or string class name. Destination instances are not accepted.
@@ -152,10 +299,7 @@ class PathMap:
         Raises:
             MissingStartInstanceError: If the cached path requires a concrete start instance but the PathMap was constructed without one.
         """
-        if isinstance(path_destination, type):
-            path_destination = path_destination.__name__
-
-        tracer = self.mapping.get((self.start_class_name, path_destination), None)
+        tracer = self._get_or_create_tracer(self._destination_name(path_destination))
         if not tracer:
             return None
         if not tracer.path:
@@ -166,18 +310,29 @@ class PathMap:
 
     def get_all_connected(self) -> set[str]:
         """
-        Return the set of destination class names that are reachable from the configured start.
+        Return the set of destination class names reachable from the configured start.
 
         Returns:
             set[str]: Destination class names reachable from the current start_class_name.
         """
+        start_class = self._classes_by_name.get(self.start_class_name)
+        if start_class is None:
+            return set()
+
         connected_classes: set[str] = set()
-        for path_tuple, path_obj in self.mapping.items():
-            if path_tuple[0] == self.start_class_name:
-                destination_class_name = path_tuple[1]
-                if path_obj.path is None:
+        visited = {start_class}
+        queue: deque[type[GeneralManager]] = deque([start_class])
+
+        while queue:
+            current_class = queue.popleft()
+            for _attr, next_class in self._edges_for_class(current_class):
+                if next_class in visited:
                     continue
-                connected_classes.add(destination_class_name)
+                visited.add(next_class)
+                if self._classes_by_name.get(next_class.__name__) is next_class:
+                    connected_classes.add(next_class.__name__)
+                queue.append(next_class)
+
         return connected_classes
 
 
@@ -191,7 +346,12 @@ class PathTracer:
     """
 
     def __init__(
-        self, start_class: type[GeneralManager], destination_class: type[GeneralManager]
+        self,
+        start_class: type[GeneralManager],
+        destination_class: type[GeneralManager],
+        path: list[str] | None = None,
+        *,
+        search: bool = True,
     ) -> None:
         """
         Initialise a path tracer between two manager classes.
@@ -199,63 +359,55 @@ class PathTracer:
         Parameters:
             start_class (type[GeneralManager]): Origin manager class where traversal begins.
             destination_class (type[GeneralManager]): Target manager class to reach.
+            path (list[str] | None): Precomputed path used by lazy PathMap lookup when search is False.
+            search (bool): Whether to compute the path during construction.
 
         Returns:
             None
         """
         self.start_class = start_class
         self.destination_class = destination_class
-        if self.start_class == self.destination_class:
-            self.path: list[str] | None = []
+        if not search:
+            self.path = path
+        elif self.start_class == self.destination_class:
+            self.path = []
         else:
-            self.path = self.create_path(start_class, [])
+            self.path = self.create_path(start_class, [], {start_class})
 
     def create_path(
-        self, current_manager: type[GeneralManager], path: list[str]
+        self,
+        current_manager: type[GeneralManager],
+        path: list[str],
+        visited_managers: set[type[GeneralManager]] | None = None,
     ) -> list[str] | None:
         """
         Recursively compute the traversal path from `current_manager` to the destination class.
 
         Candidate edges come from `Interface.get_attribute_types()` entries that
         expose a `type` key and from `@GraphQLProperty` return annotations. Only
-        GeneralManager subclasses are traversed. The search skips attributes
-        already in the current path and skips edges back to the original start
-        class to avoid cycles.
+        GeneralManager subclasses are traversed. Each manager class is expanded
+        at most once, which bounds missing-path and cyclic graph searches.
 
         Parameters:
             current_manager (type[GeneralManager]): Manager class used as the current traversal node.
             path (list[str]): Sequence of attribute names accumulated along the traversal.
+            visited_managers (set[type[GeneralManager]] | None): Manager classes already expanded during this search.
 
         Returns:
             list[str] | None: Updated list of attribute names leading to the destination, or None if no route exists.
         """
-        current_connections: dict[str, object] = {}
-        for (
-            attr_name,
-            attr_value,
-        ) in current_manager.Interface.get_attribute_types().items():
-            if isinstance(attr_value, Mapping):
-                current_connections[attr_name] = attr_value.get("type")
-        for attr_name, attr_value in current_manager.__dict__.items():
-            if not isinstance(attr_value, GraphQLProperty):
-                continue
-            type_hints = get_args(attr_value.graphql_type_hint)
-            field_type = (
-                type_hints[0]
-                if type_hints
-                else cast(type[object], attr_value.graphql_type_hint)
-            )
-            current_connections[attr_name] = field_type
-        for attr, attr_type in current_connections.items():
-            if attr in path or attr_type == self.start_class:
-                continue
-            if attr_type is None or not isinstance(attr_type, type):
-                continue
-            if not issubclass(attr_type, GeneralManager):
+        if visited_managers is None:
+            visited_managers = {current_manager}
+
+        for attr, attr_type in _iter_manager_connections(current_manager):
+            if attr_type == self.start_class:
                 continue
             if attr_type == self.destination_class:
                 return [*path, attr]
-            result = self.create_path(attr_type, [*path, attr])
+            if attr_type in visited_managers:
+                continue
+            visited_managers.add(attr_type)
+            result = self.create_path(attr_type, [*path, attr], visited_managers)
             if result:
                 return result