cooptools 1.62__tar.gz → 1.63__tar.gz

{cooptools-1.62 → cooptools-1.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cooptools
-Version: 1.62
+Version: 1.63
 Summary: Generic Tooling
 Home-page: https://github.com/tylertjburns/cooptools
 Author: tburns

{cooptools-1.62 → cooptools-1.63}/cooptools/graphs/graph.py

@@ -673,16 +673,9 @@ class Graph(object):
                 if e_in: msg += f" the end \'{end.name}\' is in the disabled_node_ids"
                 raise Exception(msg)
 
-            for x in disabled_node_ids:
-                self.disable_edges_to_node(
-                    node=self.node_by_name(node_name=x),
-                    disabler=INTERNAL_DISABLER
-                )
-
         if not ignored_disablers:
             ignored_disablers = []
 
-        """Returns a list of nodes as a path from the given start to the given end in the given graph"""
         logger.debug(f"Performing A* over map of length: {len(self._graph_dict)}")
 
         # Create start and end node
@@ -695,9 +688,11 @@ class Graph(object):
         open_set = set()
         closed_set = set()
 
-        enabled_connections_to_end = self.edges_to_node(end, only_enabled=True, ignored_disablers=ignored_disablers)
-        if len(enabled_connections_to_end) != 0:
-            # Add the start node
+        # Check reachability: any enabled edge into end whose source isn't disabled
+        connections_to_end = self.edges_to_node(end, only_enabled=True, ignored_disablers=ignored_disablers)
+        if disabled_node_ids is not None:
+            connections_to_end = [e for e in connections_to_end if e.start.name not in disabled_node_ids]
+        if len(connections_to_end) != 0:
             open_set.add(start_iter)
 
         cc = -1
@@ -742,12 +737,15 @@ class Graph(object):
                                        steps,
                                        source=start,
                                        dest=end,
-                                       disabled_node_ids=list(disabled_node_ids) if disabled_node_ids is not None else None)  # Return reversed path
+                                       disabled_node_ids=list(disabled_node_ids) if disabled_node_ids is not None else None)
                 break
 
             # Generate children
             for new_node in self._graph_dict[current_item.graph_node]:  # Adjacent nodes
-                # edges
+                # Skip nodes excluded by the caller — checked inline to avoid mutating the graph
+                if disabled_node_ids is not None and new_node.name in disabled_node_ids:
+                    continue
+
                 edges = self.edges_between(
                     nodeA=current_item.graph_node,
                     nodeB=new_node
@@ -758,8 +756,8 @@ class Graph(object):
                 if len(enabled_edges) == 0:
                     continue
 
-                # find the min-lenght edge
-                enabled_edges.sort(key=lambda x: x.length)
+                # find the min-cost edge
+                enabled_edges.sort(key=lambda x: x.cost)
                 min_edge = enabled_edges[0]
 
                 new_item = AStarMetrics(current_item, new_node, min_edge)
@@ -797,17 +795,9 @@ class Graph(object):
                                failure_reason=failure_reason,
                     )
         else:
-            ''' Log Path found '''
             logger.debug(f"Path found from [{start}] to [{end}] in {len(steps)} steps")
             ret = results
 
-        if disabled_node_ids is not None:
-            for x in disabled_node_ids:
-                self.enable_edges_to_node(
-                    node=self.node_by_name(node_name=x),
-                    disabler=INTERNAL_DISABLER
-                )
-
         return ret
 
     def path_length(self, path:List[Node]):
@@ -1041,6 +1031,199 @@ class Graph(object):
                 branches_graph_dict.pop(src, None)
         return Graph(branches_graph_dict), steps
 
+    def greedy_target_seek(self,
+                           sources: Iterable[Node],
+                           targets: Iterable[Node],
+                           disabled_node_ids: frozenset[str] = None) -> Tuple[Self, list[dict]]:
+        """Grow a spanning tree from sources toward all targets using greedy path commitment.
+
+        Unlike branching_target_seek (which advances one hop per outer iteration),
+        this function advances each frontier along its full planned A* path until it
+        collides with a node already committed to the tree.  Cheaper paths commit
+        first, so shared trunk segments are claimed before branches check for
+        collisions — this produces the correct branching topology in O(branch_depth)
+        outer iterations instead of O(max_path_length).
+
+        Returns:
+            Tuple of (Graph, steps) mirroring branching_target_seek's interface.
+        """
+        if disabled_node_ids is not None:
+            for x in disabled_node_ids:
+                self.disable_edges_to_node(
+                    node=self.node_by_name(node_name=x),
+                    disabler=INTERNAL_DISABLER
+                )
+
+        source_set: set[Node]        = set(sources)
+        active_nodes: set[Node]      = set(sources)
+        current_targets: set[Node]   = set(targets)
+        branches_graph_dict: Dict[Node, list] = {x: [] for x in sources}
+        in_tree: set[Node]           = set(sources)
+        parent_map: Dict[Node, Node] = {}
+        reached_targets: set[Node]   = set()
+
+        steps: list[dict] = []
+
+        def _snap(label, new_edges=None, best_routes=None, pruned=None):
+            steps.append({
+                "label":       label,
+                "active":      frozenset(active_nodes),
+                "targets":     frozenset(current_targets),
+                "in_tree":     frozenset(in_tree),
+                "branches":    {k: list(v) for k, v in branches_graph_dict.items()},
+                "new_edges":   list(new_edges or []),
+                "best_routes": list(best_routes or []),
+                "pruned":      list(pruned or []),
+            })
+
+        _snap("Initial state")
+
+        while len(current_targets) > 0:
+            target_nearest: Dict[Node, AStarResults] = {}
+
+            # Find the best full A* path from any active node to each target
+            for node in active_nodes:
+                for target in current_targets:
+                    route = self.astar(start=node, end=target)
+                    target_nearest.setdefault(target, None)
+                    if route.nodes is not None and len(route.nodes) > 0 and (
+                        target_nearest.get(target) is None or
+                        route.Cost < target_nearest[target].Cost
+                    ):
+                        target_nearest[target] = route
+
+            # Discard targets with no reachable path
+            for target in list(current_targets):
+                route = target_nearest.get(target)
+                if route is None or not route.nodes or len(route.nodes) < 2:
+                    current_targets.discard(target)
+
+            if not current_targets:
+                break
+
+            best_routes_display = [
+                list(r.nodes) for r in target_nearest.values()
+                if r is not None and r.nodes is not None and len(r.nodes) > 0
+            ]
+            _snap("Routes found", best_routes=best_routes_display)
+
+            # Identify which active nodes hold at least one best route this iteration
+            contributing: set[Node] = set()
+            for target, route in target_nearest.items():
+                if target in current_targets and route is not None and route.nodes:
+                    contributing.add(list(route.nodes)[0])
+
+            # Prune dominated active nodes back to the last branch.
+            # Reached targets are exempt — they stay active so the tree can
+            # extend through them toward further targets.
+            pruned_this_step: list[Node] = []
+            dominated = active_nodes - contributing - reached_targets
+            for dominated_node in dominated:
+                current = dominated_node
+                while current not in source_set:
+                    parent = parent_map.get(current)
+                    active_nodes.discard(current)
+                    in_tree.discard(current)
+                    branches_graph_dict.pop(current, None)
+                    parent_map.pop(current, None)
+                    if parent is not None:
+                        children = branches_graph_dict.get(parent, [])
+                        if current in children:
+                            children.remove(current)
+                    pruned_this_step.append(current)
+                    if parent is None or parent in source_set:
+                        break
+                    if branches_graph_dict.get(parent, []):
+                        break
+                    if parent in contributing:
+                        active_nodes.add(parent)
+                        break
+                    current = parent
+
+            if pruned_this_step:
+                _snap("Pruned dominated nodes", pruned=pruned_this_step)
+
+            # Advance each frontier along its full planned path until it collides
+            # with a node already in the tree.  Cheaper paths commit first.
+            reachable = [
+                (t, r) for t, r in target_nearest.items()
+                if t in current_targets and r is not None and r.nodes and len(r.nodes) >= 2
+            ]
+            reachable.sort(key=lambda x: x[1].Cost)
+
+            new_edges: list[tuple[Node, Node]] = []
+
+            for target, best_route in reachable:
+                if target not in current_targets:
+                    continue
+
+                path_nodes = list(best_route.nodes)
+                from_node = path_nodes[0]
+                active_nodes.discard(from_node)
+
+                prev = from_node
+                new_frontier = from_node
+                left_shared_prefix = False
+
+                for node in path_nodes[1:]:
+                    if node in in_tree:
+                        if not left_shared_prefix:
+                            # Fast-forward through the shared trunk without committing.
+                            # The trunk is already in the tree; we just find where our
+                            # path diverges from it.
+                            prev = node
+                            new_frontier = node
+                        else:
+                            # Our new branch segment reconnects to an existing tree node
+                            # (confluence / tributary join).  Wire it in and stop.
+                            branches_graph_dict.setdefault(prev, [])
+                            if node not in branches_graph_dict[prev]:
+                                branches_graph_dict[prev].append(node)
+                            new_frontier = node
+                            break
+                    else:
+                        left_shared_prefix = True
+                        branches_graph_dict.setdefault(prev, [])
+                        if node not in branches_graph_dict[prev]:
+                            branches_graph_dict[prev].append(node)
+                        branches_graph_dict.setdefault(node, [])
+                        in_tree.add(node)
+                        parent_map[node] = prev
+                        new_edges.append((prev, node))
+                        prev = node
+                        new_frontier = node
+                        if node == target:
+                            break
+
+                active_nodes.add(new_frontier)
+
+                if new_frontier == target or new_frontier in current_targets:
+                    current_targets.discard(new_frontier)
+                    current_targets.discard(target)
+                    reached_targets.add(new_frontier)
+
+            # Post-commit sweep: a path's walk may have passed through another target's
+            # node en route to its own target.  Mark any such targets as reached now.
+            for t in list(current_targets):
+                if t in in_tree:
+                    current_targets.discard(t)
+                    reached_targets.add(t)
+                    active_nodes.discard(t)
+
+            _snap("Edges added", new_edges=new_edges, best_routes=best_routes_display)
+
+        if disabled_node_ids is not None:
+            for x in disabled_node_ids:
+                self.enable_edges_to_node(
+                    node=self.node_by_name(node_name=x),
+                    disabler=INTERNAL_DISABLER
+                )
+
+        for src in list(source_set):
+            if branches_graph_dict.get(src) == []:
+                branches_graph_dict.pop(src, None)
+        return Graph(branches_graph_dict), steps
+
     @property
     def SectorGraph(self) -> Self:
         client_mappings = self._sec_tree.ClientMappings

{cooptools-1.62 → cooptools-1.63}/cooptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cooptools
-Version: 1.62
+Version: 1.63
 Summary: Generic Tooling
 Home-page: https://github.com/tylertjburns/cooptools
 Author: tburns

{cooptools-1.62 → cooptools-1.63}/setup.py

@@ -7,7 +7,7 @@ with open('requirements.txt') as f:
     requirements = f.read().splitlines()
 
 setuptools.setup(name='cooptools',
-      version='1.62',
+      version='1.63',
       description='Generic Tooling',
       url='https://github.com/tylertjburns/cooptools',
       author='tburns',