cooptools 1.61__tar.gz → 1.63__tar.gz

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

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

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

@@ -405,8 +405,8 @@ class Graph(object):
 
         if isinstance(node, str):
             node = self.node_by_name(node)
-    
-        node_edges = self._node_edge_map[node]
+
+        node_edges = self._node_edge_map.get(node, [])
         ret = [self._edges_dict[edge_id] for edge_id in node_edges if self._edges_dict[edge_id].end == node]
 
         if only_enabled:
@@ -416,11 +416,11 @@ class Graph(object):
 
     def edges_including_node(self, node: Node | str, only_enabled: bool = False, ignored_disablers: List[str] = None) -> List[Edge]:
         if isinstance(node, str):
-            node = self.node_by_name(node)  
+            node = self.node_by_name(node)
 
         if not isinstance(node, Node):
             raise Exception(f"input must be of type {Node}, but {type(node)} was provided")
-        node_edges = self._node_edge_map[node]
+        node_edges = self._node_edge_map.get(node, [])
         ret = [self._edges_dict[edge_id] for edge_id in node_edges]
 
         if only_enabled:
@@ -431,7 +431,7 @@ class Graph(object):
     def edges_from_node(self, node: Node, only_enabled: bool = False, ignored_disablers: List[str] = None) -> List[Edge]:
         if not isinstance(node, Node):
             raise Exception(f"input must be of type {Node}, but {type(node)} was provided")
-        node_edges = self._node_edge_map[node]
+        node_edges = self._node_edge_map.get(node, [])
         ret = [self._edges_dict[edge_id] for edge_id in node_edges if self._edges_dict[edge_id].start == node]
 
         if only_enabled:
@@ -444,7 +444,7 @@ class Graph(object):
         logger.debug(f"disable {node} with disabler {disabler}")
 
         if isinstance(node, Node):
-            node_edges = self._node_edge_map[node]
+            node_edges = self._node_edge_map.get(node, [])
             for edge_id in node_edges:
                 edge = self._edges_dict[edge_id]
                 edge.add_disabler(disabler)
@@ -453,7 +453,7 @@ class Graph(object):
         logger.debug(f"enable {node} on disabler {disabler}")
 
         if isinstance(node, Node):
-            node_edges = self._node_edge_map[node]
+            node_edges = self._node_edge_map.get(node, [])
             for edge_id in node_edges:
                 edge = self._edges_dict[edge_id]
                 edge.remove_disabler(disabler)
@@ -662,7 +662,8 @@ class Graph(object):
               g_func: Callable[[Node, Node], float] = None,
               h_func: Callable[[Node, Node], float] = None,
               ignored_disablers:frozenset[str]=None,
-              disabled_node_ids:frozenset[str] = None) -> AStarResults:
+              disabled_node_ids:frozenset[str] = None,
+              early_out_cost: float = None) -> AStarResults:
 
         if disabled_node_ids is not None:
             if ((s_in:=(start.name in disabled_node_ids)) or
@@ -672,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
@@ -694,14 +688,17 @@ 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
 
         results = None
+        _early_out_triggered = False
         # Loop until you find the end
         while len(open_set) > 0:
             cc += 1
@@ -712,6 +709,13 @@ class Graph(object):
                 if open_item.f < current_item.f:
                     current_item = open_item
 
+            # Early-out: f is a lower bound on total path cost through current_item.
+            # If the minimum f in the open set already meets or exceeds the caller's
+            # cost ceiling, no reachable path can improve on what's already known.
+            if early_out_cost is not None and current_item.f >= early_out_cost:
+                _early_out_triggered = True
+                break
+
             steps[cc] = {"open_set": set(open_set), "closed_set": set(closed_set), "current_item": current_item}
 
             # Pop current off open list, add to closed list
@@ -733,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
@@ -749,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)
@@ -761,8 +768,7 @@ class Graph(object):
                 open_set.add(new_item)
 
                 # calculate new g, h, f from current pivot node to the new node
-                calc_g = current_item.g + g_func(current_item.graph_node,
-                                                 new_node) if g_func else vec.distance_between(new_node.pos, current_item.graph_node.pos)
+                calc_g = current_item.g + (g_func(current_item.graph_node, new_node) if g_func else min_edge.cost)
                 calc_h = h_func(new_node,
                                 end_iter.graph_node) if h_func else vec.distance_between(new_node.pos, end_iter.graph_node.pos)
                 calc_f = calc_g + calc_h
@@ -773,28 +779,25 @@ class Graph(object):
                 new_item.f = calc_f
 
         if results is None:
-            ''' No Path Found '''
-            logger.error(f"Unable to find a path from [{start}] to [{end}]")
+            if _early_out_triggered:
+                logger.debug(f"A* early-out from [{start}] to [{end}]: f >= early_out_cost ({early_out_cost})")
+                failure_reason = RouteFailureReason.EARLY_OUT_REACHED
+            else:
+                logger.error(f"Unable to find a path from [{start}] to [{end}]")
+                failure_reason = RouteFailureReason.ROUTE_NOT_POSSIBLE
 
             ret = AStarResults([],
                                [],
                                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,
+                               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]):
@@ -890,67 +893,336 @@ class Graph(object):
     def branching_target_seek(self,
                               sources: Iterable[Node],
                               targets: Iterable[Node],
-                              disabled_node_ids:frozenset[str] = None):
+                              disabled_node_ids: frozenset[str] = None) -> Tuple[Self, list[dict]]:
+        """Grow a spanning tree from sources toward all targets one step at a time.
+
+        Returns:
+            Tuple of (Graph, steps) where steps is a list of dicts capturing
+            algorithm state after each phase of each iteration.
+        """
         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
                 )
-        
-        active_nodes: set[Node] = set(sources)
-        current_targets: set[Node] = set(targets)
-        branches_graph_dict = {
-            x: [] for x in sources
-        }
 
-        routes = {}
+        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()  # targets already reached — never prune these
+
+        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 []),    # list of (Node, Node) pairs
+                "best_routes": list(best_routes or []),  # list of Node sequences
+                "pruned":      list(pruned or []),        # list of Nodes removed this step
+            })
+
+        _snap("Initial state")
 
         while len(current_targets) > 0:
             target_nearest: Dict[Node, AStarResults] = {}
 
-            # Calculate routes from active nodes to targets
+            # Calculate cheapest route from any active node to each target
             for node in active_nodes:
                 for target in current_targets:
-                    route = self.astar(
-                        start=node,
-                        end=target
-                    )
-
+                    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):
+                    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
 
-            # progress the branches
+            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 route in target_nearest.values():
+                if route is not None and route.nodes is not None and len(route.nodes) > 0:
+                    contributing.add(list(route.nodes)[0])
+
+            # Prune dominated active nodes (hold no best route) back to the last branch.
+            # Contributing nodes advance monotonically closer to remaining targets, so a
+            # dominated node will never win a future iteration.
+            # 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  # parent still has other children — real branch node
+                    if parent in contributing:
+                        active_nodes.add(parent)  # restore contributing parent to active
+                        break
+                    current = parent  # cascade prune
+
+            if pruned_this_step:
+                _snap("Pruned dominated nodes", pruned=pruned_this_step)
+
+            # Progress the branches one step toward each target
+            new_edges: list[tuple[Node, Node]] = []
             for target, best_route in target_nearest.items():
-                if best_route.nodes is None or len(best_route.nodes) == 0:
-                    current_targets.remove(target)
+                if target not in current_targets:
                     continue
 
-                from_node = list(best_route.nodes)[0]
+                if best_route is None or best_route.nodes is None or len(best_route.nodes) == 0:
+                    current_targets.discard(target)
+                    continue
+
+                from_node   = list(best_route.nodes)[0]
+                first_visit = list(best_route.nodes)[1]
 
                 if from_node in active_nodes:
                     active_nodes.remove(from_node)
 
-                # skip the node where started, and grab the next visited
-                first_visit = list(best_route.nodes)[1]
+                if first_visit not in in_tree:
+                    branches_graph_dict[from_node].append(first_visit)
+                    branches_graph_dict.setdefault(first_visit, [])
+                    active_nodes.add(first_visit)
+                    in_tree.add(first_visit)
+                    parent_map[first_visit] = from_node
+                    new_edges.append((from_node, first_visit))
 
-                # build the branch
-                branches_graph_dict[from_node].append(first_visit)
-                branches_graph_dict.setdefault(first_visit, [])
+                if first_visit in current_targets:
+                    current_targets.discard(first_visit)
+                    reached_targets.add(first_visit)
 
-                # add new node to eligible active nodes
-                active_nodes.add(first_visit)
+            _snap("Edges added", new_edges=new_edges, best_routes=best_routes_display)
 
-                # if have reached a target, remove from targets
-                if first_visit in current_targets:
-                    current_targets.remove(first_visit)
+        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
+
+    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
+                )
 
-        # return
-        for src in list(sources):
+        for src in list(source_set):
             if branches_graph_dict.get(src) == []:
                 branches_graph_dict.pop(src, None)
-        return Graph(branches_graph_dict)
+        return Graph(branches_graph_dict), steps
 
     @property
     def SectorGraph(self) -> Self:

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

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

{cooptools-1.61 → 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.61',
+      version='1.63',
       description='Generic Tooling',
       url='https://github.com/tylertjburns/cooptools',
       author='tburns',