cooptools 1.74__tar.gz → 1.76__tar.gz

{cooptools-1.74 → cooptools-1.76}/PKG-INFO

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

{cooptools-1.74 → cooptools-1.76}/cooptools/common.py

@@ -1,6 +1,6 @@
 import math
 import uuid
-from typing import List, Union, Tuple, Iterable, Callable, Sequence, TypeVar, Dict
+from typing import List, Union, Tuple, Iterable, Callable, Sequence, TypeVar, Dict, Optional
 import itertools
 import numpy as np
 import bisect
@@ -145,11 +145,15 @@ def verify_unique(lst: Iterable, error_msg: str = None):
 def verify_len_match(iterable1,
                      iterable2,
                      error_msg: str = None,
-                     block:bool = True):
-    msg = f"{iterable1} and {iterable2} do not have the same length ({len(iterable1)} vs {len(iterable2)})"
+                     block:bool = True) -> Optional[int]:
+    # Length is compared before the message is built. This sits under
+    # rect_contains_point on the sector-tree insert path, where formatting a
+    # message for a check that passes costs more than the check itself.
+    if (l1:=len(iterable1)) == len(iterable2):
+        return l1
 
-    tst = lambda: len(iterable1) == len(iterable2)
-    verify(tst, msg, error_msg, block=block)
+    msg = f"{iterable1} and {iterable2} do not have the same length ({len(iterable1)} vs {len(iterable2)})"
+    verify(lambda: False, msg, error_msg, block=block)
 
 def verify_len(iterable, length: int, error_msg: str = None):
     msg = f"{iterable} does not have len {length} ({len(iterable)})"

{cooptools-1.74 → cooptools-1.76}/cooptools/geometry_utils/vector_utils.py

@@ -108,12 +108,30 @@ def vector_between(start: FloatVec,
                    allow_diff_lengths: bool = False
                    ) -> FloatVec:
     if not allow_diff_lengths:
-        verify_len_match(start, end)
+        l_start = verify_len_match(start, end)
+        l_end = l_start
+    else:
+        l_start, l_end = len(start), len(end)
+
+    # 2- and 3-D vectors are most of the traffic here, and for them the loop
+    # below costs far more than the subtractions it performs: a range, two
+    # bounds-checked conditionals per axis, a list append per axis, and a
+    # tuple() at the end. Naming the axes skips all of it.
+    #
+    # Equal lengths are part of the condition because that is the only case in
+    # which the loop's padding cannot apply; an unequal pair falls through and
+    # is padded or truncated exactly as before.
+    if l_start == l_end == 2:
+        return (end[0] - start[0], end[1] - start[1])
+
+    if l_start == l_end == 3:
+        return (end[0] - start[0], end[1] - start[1], end[2] - start[2])
 
     ret = []
-    for idx in range(len(start)):
-        e = end[idx] if idx < len(end) else 0
-        s = start[idx] if idx < len(start) else 0
+
+    for idx in range(l_start):
+        e = end[idx] if idx < l_end else 0
+        s = start[idx] if idx < l_start else 0
 
         ret.append((e - s))
 
@@ -175,7 +193,23 @@ def scale_vector_length(a: FloatVec, scale: float) -> FloatVec:
 
 
 def vector_len(a: FloatVec, squared: bool = False) -> float:
-    sum_sq = sum(ii ** 2 for ii in a)
+    # 2- and 3-D vectors are most of the traffic here, and for them the general
+    # branch spends more on interpreter overhead than on arithmetic: a generator
+    # object plus one resumption of it per axis, driven by sum(). Naming the
+    # axes skips both.
+    #
+    # sum() applies compensated (Neumaier) summation to floats, so for three
+    # terms it can land a ULP away from the plain addition used here. That
+    # difference is accepted: a ULP sits far below the precision a caller of a
+    # vector length can meaningfully rely on.
+    len_a = len(a)
+    if len_a == 2:
+        sum_sq = a[0] * a[0] + a[1] * a[1]
+    elif len_a == 3:
+        sum_sq = a[0] * a[0] + a[1] * a[1] + a[2] * a[2]
+    else:
+        sum_sq = sum(ii * ii for ii in a)
+
     return sum_sq if squared else math.sqrt(sum_sq)
 
 

{cooptools-1.74 → cooptools-1.76}/cooptools/graphs/graph.py

@@ -306,12 +306,17 @@ class Graph(object):
 
     @property
     def Sources(self) -> List[Node]:
-        dests = self.DestinationNodes
+        # Membership is tested once per node, so the destinations are hashed
+        # rather than scanned -- DestinationNodes hands back a list.
+        dests = set(self.DestinationNodes)
         return [n for n, cnxn in self._graph_dict.items() if n not in dests and len(cnxn) != 0]
 
     @property
     def Sinks(self) -> List[Node]:
-        return [n for n, cnxn in self._graph_dict.items() if len(cnxn) == 0 and n not in self.Orphans]
+        # Orphans walks the whole node-edge map, so it is built once for the
+        # scan instead of once per node.
+        orphans = set(self.Orphans)
+        return [n for n, cnxn in self._graph_dict.items() if len(cnxn) == 0 and n not in orphans]
 
     @property
     def Orphans(self) -> List[Node]:
@@ -734,6 +739,11 @@ class Graph(object):
         if not ignored_disablers:
             ignored_disablers = []
 
+        # Hoisted out of the expansion loop below, which tests it once per edge
+        # considered -- millions of times on a large graph. Edge.enabled needs a
+        # set, so building one here keeps that per-edge cost to a lookup.
+        _ignored_disablers_set = set(ignored_disablers)
+
         logger.debug(f"Performing A* over map of length: {len(self._graph_dict)}")
 
         # Create start and end node
@@ -816,7 +826,7 @@ class Graph(object):
                 )
 
                 # Dont evaluate this node if the edge is not enabled
-                enabled_edges = [x for x in edges if x.enabled(ignored_disablers=set(ignored_disablers))]
+                enabled_edges = [x for x in edges if x.enabled(ignored_disablers=_ignored_disablers_set)]
                 if len(enabled_edges) == 0:
                     continue
 

{cooptools-1.74 → cooptools-1.76}/cooptools/graphs/graph_dcs.py

@@ -165,8 +165,13 @@ class Edge(object):
         return self.length
 
     def enabled(self, ignored_disablers: set = None):
+        # An edge with no disablers is enabled whatever the caller ignores, and
+        # that is the overwhelmingly common case on a pathfinding hot loop --
+        # answering it first avoids allocating an empty set per call.
+        if not self._disablers:
+            return True
         if ignored_disablers is None:
-            ignored_disablers = set()
+            return False
         return self._disablers.issubset(ignored_disablers)
 
 

{cooptools-1.74 → cooptools-1.76}/cooptools/sectors/sectorTree/sectorTree.py

@@ -161,10 +161,14 @@ class SectorTree:
         for client, type in clients.items():
             ii += 1
             if self.lvl == 0:
-                if client in self.Clients:
-                    logger.info(f"[{self._id}] User requests updating {ii}/{len(clients)} [{client}]")
-                else:
-                    logger.info(f"[{self._id}] User requests adding {ii}/{len(clients)} [{client}]")
+                # Whether this client is already known is read from
+                # _last_mapped_pos -- the same dict remove_clients treats as the
+                # membership record -- because it answers in constant time. The
+                # Clients property flattens every sector mapping in the tree, so
+                # consulting it once per client made registering a batch
+                # quadratic in the size of the batch.
+                verb = "updating" if client in self._last_mapped_pos else "adding"
+                logger.info(f"[{self._id}] User requests {verb} {ii}/{len(clients)} [{client}]")
 
                 if not client.__hash__:
                     raise Exception(f"Client {client} must be hashable, but type {type(client)} is not")

{cooptools-1.74 → cooptools-1.76}/cooptools.egg-info/PKG-INFO

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

{cooptools-1.74 → cooptools-1.76}/cooptools.egg-info/SOURCES.txt

@@ -163,6 +163,7 @@ tests/test_date_utils.py
 tests/test_flow_field.py
 tests/test_flow_field_perf.py
 tests/test_fund_projection.py
+tests/test_graph_node_classification.py
 tests/test_kinematicGoalSeeker.py
 tests/test_kinematic_utils.py
 tests/test_os_manip.py

{cooptools-1.74 → cooptools-1.76}/setup.py

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

cooptools-1.76/tests/test_graph_node_classification.py

@@ -0,0 +1,142 @@
+import unittest
+
+from cooptools.common import verify_len_match
+from cooptools.graphs import Graph, Node
+from cooptools.graphs.graph_dcs import Edge
+
+
+class TestNodeClassification(unittest.TestCase):
+    """Sources/Sinks/Orphans partition a graph's nodes by their edge directions."""
+
+    @staticmethod
+    def _graph():
+        # a -> b -> c    (a is a source, c is a sink)
+        # d              (no edges at all -- an orphan)
+        a = Node(name='A', pos=(0.0, 0.0))
+        b = Node(name='B', pos=(1.0, 0.0))
+        c = Node(name='C', pos=(2.0, 0.0))
+        d = Node(name='D', pos=(9.0, 9.0))
+        return Graph({a: [b], b: [c], c: [], d: []})
+
+    def test_Sources_returns_only_nodes_nothing_points_at(self):
+        self.assertEqual(['A'], [n.name for n in self._graph().Sources])
+
+    def test_Sinks_returns_connected_nodes_with_no_outbound_edge(self):
+        self.assertEqual(['C'], [n.name for n in self._graph().Sinks])
+
+    def test_Sinks_excludes_orphans(self):
+        # D has no edges in either direction, so it is an orphan rather than a
+        # sink -- the two categories must not both claim it.
+        graph = self._graph()
+        self.assertNotIn('D', [n.name for n in graph.Sinks])
+        self.assertIn('D', [n.name for n in graph.Orphans])
+
+    def test_Orphans_returns_only_wholly_unconnected_nodes(self):
+        self.assertEqual(['D'], [n.name for n in self._graph().Orphans])
+
+    def test_a_node_is_never_both_a_source_and_a_sink(self):
+        graph = self._graph()
+        sources = {n.name for n in graph.Sources}
+        sinks = {n.name for n in graph.Sinks}
+        self.assertEqual(set(), sources & sinks)
+
+    def test_fully_connected_cycle_has_no_sources_sinks_or_orphans(self):
+        a = Node(name='A', pos=(0.0, 0.0))
+        b = Node(name='B', pos=(1.0, 0.0))
+        graph = Graph({a: [b], b: [a]})
+        self.assertEqual([], graph.Sources)
+        self.assertEqual([], graph.Sinks)
+        self.assertEqual([], graph.Orphans)
+
+
+class TestEdgeEnabled(unittest.TestCase):
+    """An edge is enabled when every disabler on it is one the caller ignores."""
+
+    @staticmethod
+    def _edge(disablers=None):
+        return Edge(Node('A', (0.0, 0.0)), Node('B', (1.0, 1.0)), disablers=disablers)
+
+    def test_edge_without_disablers_is_enabled_when_nothing_is_ignored(self):
+        self.assertTrue(self._edge().enabled(None))
+
+    def test_edge_without_disablers_is_enabled_whatever_is_ignored(self):
+        self.assertTrue(self._edge().enabled({'anything'}))
+
+    def test_disabled_edge_is_not_enabled_when_nothing_is_ignored(self):
+        self.assertFalse(self._edge(['d1']).enabled(None))
+        self.assertFalse(self._edge(['d1']).enabled(set()))
+
+    def test_disabled_edge_is_enabled_once_its_disabler_is_ignored(self):
+        self.assertTrue(self._edge(['d1']).enabled({'d1'}))
+
+    def test_edge_needs_every_one_of_its_disablers_ignored(self):
+        edge = self._edge(['d1', 'd2'])
+        self.assertFalse(edge.enabled({'d1'}))
+        self.assertTrue(edge.enabled({'d1', 'd2'}))
+
+    def test_ignoring_an_unrelated_disabler_does_not_enable_the_edge(self):
+        self.assertFalse(self._edge(['d1']).enabled({'other'}))
+
+    def test_ignored_disablers_may_be_any_iterable(self):
+        self.assertTrue(self._edge(['d1']).enabled(['d1']))
+
+
+class TestAStarIgnoredDisablers(unittest.TestCase):
+    """A* may only traverse a disabled edge when told to ignore its disabler."""
+
+    @staticmethod
+    def _graph_with_a_disabled_shortcut():
+        # A -> B is the only route; disabling it makes the graph unroutable.
+        a = Node(name='A', pos=(0.0, 0.0))
+        b = Node(name='B', pos=(1.0, 0.0))
+        graph = Graph({a: [b], b: []})
+        for edge in graph.Edges.values():
+            edge.add_disabler('BLOCKED')
+        return graph, a, b
+
+    def test_route_is_not_found_across_a_disabled_edge(self):
+        graph, a, b = self._graph_with_a_disabled_shortcut()
+        self.assertFalse(graph.astar(a, b).Success)
+
+    def test_route_is_found_when_the_disabler_is_ignored(self):
+        graph, a, b = self._graph_with_a_disabled_shortcut()
+        results = graph.astar(a, b, ignored_disablers=frozenset({'BLOCKED'}))
+        self.assertTrue(results.Success)
+        self.assertEqual(['A', 'B'], [n.name for n in results.nodes])
+
+    def test_ignored_disablers_accepts_a_list_as_well_as_a_set(self):
+        graph, a, b = self._graph_with_a_disabled_shortcut()
+        self.assertTrue(graph.astar(a, b, ignored_disablers=['BLOCKED']).Success)
+
+    def test_ignoring_an_unrelated_disabler_leaves_the_edge_closed(self):
+        graph, a, b = self._graph_with_a_disabled_shortcut()
+        self.assertFalse(graph.astar(a, b, ignored_disablers=frozenset({'SOMETHING_ELSE'})).Success)
+
+
+class TestVerifyLenMatch(unittest.TestCase):
+
+    def test_matching_lengths_return_the_shared_length(self):
+        # The length is handed back so callers that need it -- vector_between
+        # being the reason -- do not have to measure the operands again.
+        self.assertEqual(2, verify_len_match((1, 2), (3, 4)))
+
+    def test_two_empties_match_and_report_zero(self):
+        self.assertEqual(0, verify_len_match((), ()))
+
+    def test_mismatch_returns_nothing_when_not_blocking(self):
+        self.assertIsNone(verify_len_match((1, 2, 3), (4, 5), block=False))
+
+    def test_mismatched_lengths_raise(self):
+        with self.assertRaises(ValueError):
+            verify_len_match((1, 2, 3), (4, 5))
+
+    def test_the_error_reports_both_lengths(self):
+        with self.assertRaises(ValueError) as ctx:
+            verify_len_match((1, 2, 3), (4, 5))
+        self.assertIn('3', str(ctx.exception))
+        self.assertIn('2', str(ctx.exception))
+
+
+
+if __name__ == '__main__':
+    unittest.main()