GeneralManager 0.60.4__tar.gz → 0.60.5__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.60.4
+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.4 → 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.4 → 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