4.24.0b2

Author: songololo

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cityseer"
-version = '4.24.0b1'
+version = '4.24.0b2'
 description = "Computational tools for network-based pedestrian-scale urban analysis"
 readme = "README.md"
 requires-python = ">=3.10, <3.14" # pending fiona support for 3.14

pysrc/cityseer/tools/graphs.py

@@ -37,14 +37,19 @@ def _node_has_z(nd_data: NodeData) -> bool:
 def _make_geom_between(nd_data_a: NodeData, nd_data_b: NodeData) -> geometry.LineString:
     """Create a LineString between two nodes, using 3D coords only if both nodes have z."""
     if _node_has_z(nd_data_a) and _node_has_z(nd_data_b):
-        return geometry.LineString([
-            (nd_data_a["x"], nd_data_a["y"], nd_data_a["z"]),
-            (nd_data_b["x"], nd_data_b["y"], nd_data_b["z"]),
-        ])
-    return geometry.LineString([
-        (nd_data_a["x"], nd_data_a["y"]),
-        (nd_data_b["x"], nd_data_b["y"]),
-    ])
+        return geometry.LineString(
+            [
+                (nd_data_a["x"], nd_data_a["y"], nd_data_a["z"]),
+                (nd_data_b["x"], nd_data_b["y"], nd_data_b["z"]),
+            ]
+        )
+    return geometry.LineString(
+        [
+            (nd_data_a["x"], nd_data_a["y"]),
+            (nd_data_b["x"], nd_data_b["y"]),
+        ]
+    )
+
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)

pysrc/cityseer/tools/io.py

@@ -101,9 +101,7 @@ def nx_epsg_conversion(
             line_geom: geometry.LineString = edge_data["geom"]
             # convert, preserving z if present
             if line_geom.has_z:
-                edge_coords: ListCoordsType = [
-                    (*transformer.transform(c[0], c[1]), c[2]) for c in line_geom.coords
-                ]
+                edge_coords: ListCoordsType = [(*transformer.transform(c[0], c[1]), c[2]) for c in line_geom.coords]
             else:
                 edge_coords = [transformer.transform(x, y) for x, y in line_geom.coords]
             # snap ends
@@ -1269,7 +1267,11 @@ def network_structure_from_gpd(
     # process nodes and build mapping
     for nd_key, node_data in tqdm(nodes_gdf.iterrows(), total=len(nodes_gdf), disable=config.QUIET_MODE):
         node_z = None
-        if "z" in node_data and node_data["z"] is not None and not (isinstance(node_data["z"], float) and np.isnan(node_data["z"])):
+        if (
+            "z" in node_data
+            and node_data["z"] is not None
+            and not (isinstance(node_data["z"], float) and np.isnan(node_data["z"]))
+        ):
             node_z = float(node_data["z"])
         ns_node_idx = network_structure.add_street_node(
             str(nd_key),
@@ -1466,7 +1468,11 @@ def nx_from_cityseer_geopandas(
         live = nd_data.live if hasattr(nd_data, "live") else True
         weight = nd_data.weight if hasattr(nd_data, "weight") else 1
         node_kwargs: dict[str, Any] = {"x": nd_data.x, "y": nd_data.y, "live": live, "weight": weight}
-        if hasattr(nd_data, "z") and nd_data.z is not None and not (isinstance(nd_data.z, float) and np.isnan(nd_data.z)):
+        if (
+            hasattr(nd_data, "z")
+            and nd_data.z is not None
+            and not (isinstance(nd_data.z, float) and np.isnan(nd_data.z))
+        ):
             node_kwargs["z"] = nd_data.z
         g_multi_copy.add_node(str(nd_key), **node_kwargs)
     logger.info("Unpacking edge data.")

tests/rustalgos/test_centrality.py

@@ -759,7 +759,9 @@ def test_simplest_betweenness_invariant_to_node_order():
         betw_by_edge = {}
         for node_pos, node_key in enumerate(nodes_gdf.index):
             row = nodes_gdf.loc[node_key]
-            edge_label = tuple(sorted((idx_to_label[row["primal_edge_node_a"]], idx_to_label[row["primal_edge_node_b"]])))
+            edge_label = tuple(
+                sorted((idx_to_label[row["primal_edge_node_a"]], idx_to_label[row["primal_edge_node_b"]]))
+            )
             betw_by_edge[edge_label] = res.node_betweenness[500][node_pos]
         results.append(betw_by_edge)
     # All orderings must agree
@@ -826,7 +828,9 @@ def test_betweenness_mixed_live_non_live_invariant_to_node_order():
         simplest_by_edge = {}
         for node_pos, node_key in enumerate(nodes_gdf_dual.index):
             row = nodes_gdf_dual.loc[node_key]
-            edge_label = tuple(sorted((idx_to_label[row["primal_edge_node_a"]], idx_to_label[row["primal_edge_node_b"]])))
+            edge_label = tuple(
+                sorted((idx_to_label[row["primal_edge_node_a"]], idx_to_label[row["primal_edge_node_b"]]))
+            )
             simplest_by_edge[edge_label] = res_simplest.node_betweenness[1000][node_pos]
         simplest_results.append(simplest_by_edge)
 
@@ -910,12 +914,8 @@ def test_shortest_brandes_tolerance_clears_stale_predecessors():
         pbar_disabled=True,
     )
 
-    exact = {
-        node_key: res_exact.node_betweenness[distance][idx] for idx, node_key in enumerate(nodes_gdf.index)
-    }
-    tolerant = {
-        node_key: res_tolerant.node_betweenness[distance][idx] for idx, node_key in enumerate(nodes_gdf.index)
-    }
+    exact = {node_key: res_exact.node_betweenness[distance][idx] for idx, node_key in enumerate(nodes_gdf.index)}
+    tolerant = {node_key: res_tolerant.node_betweenness[distance][idx] for idx, node_key in enumerate(nodes_gdf.index)}
 
     assert np.isclose(exact["A"], 0.0, atol=config.ATOL)
     assert np.isclose(exact["B"], 0.0, atol=config.ATOL)

tests/rustalgos/test_data.py

@@ -456,50 +456,50 @@ def test_aggregate_to_src_idx(primal_graph, dual_graph):
             data_map = mock.mock_data_map(data_gdf, dedupe_key_col=dedupe_key_col)
             data_map.assign_data_to_network(network_structure_d, 400, n_nearest_candidates=6)
             for netw_src_idx in network_structure_d.node_indices():
-                    # aggregate to src...
-                    reachable_entries = data_map.aggregate_to_src_idx(
-                        netw_src_idx, network_structure_d, int(max_seconds), config.SPEED_M_S, angular=True
-                    )
-                    # compare to manual checks on distances:
-                    # get the network distances
-                    _nodes, tree_map = network_structure_d.dijkstra_tree_simplest(
-                        netw_src_idx, int(max_seconds), config.SPEED_M_S
-                    )
-                    # check that reachable entries and respective distances are correct
-                    # should match against the network structure plus data_map.node_data_map distances
-                    manual_reachable = {}
-                    manual_not_reachable = {}
-                    for node_idx, node_visit in enumerate(tree_map):  # type: ignore
-                        if np.isfinite(node_visit.agg_seconds):
-                            if node_idx not in data_map.node_data_map:
-                                continue
-                            for assigned_data_idx, assigned_data_dist in data_map.node_data_map[node_idx]:
-                                dist = node_visit.agg_seconds * config.SPEED_M_S + assigned_data_dist
-                                if dist <= max_dist:
-                                    manual_reachable[assigned_data_idx] = dist
-                                else:
-                                    manual_not_reachable[assigned_data_idx] = dist
-                    # all reachable entries should be in manual reachable and distances should be the same
-                    for reachable_key, reachable_dist in reachable_entries.items():
-                        assert reachable_key in manual_reachable
-                        assert reachable_dist - manual_reachable[reachable_key] < config.ATOL
-                    # manual reachable shouldn't contain keys not in reachable entries
-                    # allow 1m tolerance for floating point errors
-                    # handle shadowed dupe id nodes in deduplication case
-                    shadowed_dupes = ["int:45", "int:46", "int:47", "int:48"]
-                    for reachable_key in manual_reachable:
-                        if deduplicate is True and reachable_key in shadowed_dupes:
-                            # if shadowed by closest dedupe node, then it should not be reachable
-                            # but if within max dist, then "int:49" should be reachable
-                            assert "int:49" in manual_reachable
-                            assert "int:49" in reachable_entries
-                            assert reachable_key not in reachable_entries
+                # aggregate to src...
+                reachable_entries = data_map.aggregate_to_src_idx(
+                    netw_src_idx, network_structure_d, int(max_seconds), config.SPEED_M_S, angular=True
+                )
+                # compare to manual checks on distances:
+                # get the network distances
+                _nodes, tree_map = network_structure_d.dijkstra_tree_simplest(
+                    netw_src_idx, int(max_seconds), config.SPEED_M_S
+                )
+                # check that reachable entries and respective distances are correct
+                # should match against the network structure plus data_map.node_data_map distances
+                manual_reachable = {}
+                manual_not_reachable = {}
+                for node_idx, node_visit in enumerate(tree_map):  # type: ignore
+                    if np.isfinite(node_visit.agg_seconds):
+                        if node_idx not in data_map.node_data_map:
                             continue
-                        try:
-                            assert reachable_key in reachable_entries
-                        except AssertionError:
-                            # If the key is not found, assert the distance condition
-                            assert max_dist - manual_reachable[reachable_key] < 1
+                        for assigned_data_idx, assigned_data_dist in data_map.node_data_map[node_idx]:
+                            dist = node_visit.agg_seconds * config.SPEED_M_S + assigned_data_dist
+                            if dist <= max_dist:
+                                manual_reachable[assigned_data_idx] = dist
+                            else:
+                                manual_not_reachable[assigned_data_idx] = dist
+                # all reachable entries should be in manual reachable and distances should be the same
+                for reachable_key, reachable_dist in reachable_entries.items():
+                    assert reachable_key in manual_reachable
+                    assert reachable_dist - manual_reachable[reachable_key] < config.ATOL
+                # manual reachable shouldn't contain keys not in reachable entries
+                # allow 1m tolerance for floating point errors
+                # handle shadowed dupe id nodes in deduplication case
+                shadowed_dupes = ["int:45", "int:46", "int:47", "int:48"]
+                for reachable_key in manual_reachable:
+                    if deduplicate is True and reachable_key in shadowed_dupes:
+                        # if shadowed by closest dedupe node, then it should not be reachable
+                        # but if within max dist, then "int:49" should be reachable
+                        assert "int:49" in manual_reachable
+                        assert "int:49" in reachable_entries
+                        assert reachable_key not in reachable_entries
+                        continue
+                    try:
+                        assert reachable_key in reachable_entries
+                    except AssertionError:
+                        # If the key is not found, assert the distance condition
+                        assert max_dist - manual_reachable[reachable_key] < 1
 
 
 def test_accessibility(primal_graph, dual_graph):