Updated new linting issues

Author: yu-ta-sato

city2graph/graph.py

@@ -574,7 +574,7 @@ def _process_hetero_edges(
 
         for edge_type, edge_gdf in edges_dict.items():
             # Extract source, relation, and destination types from edge_type tuple
-            src_type, rel_type, dst_type = edge_type
+            src_type, _, dst_type = edge_type
 
             # Get the mapping dictionaries (not the full metadata)
             # The type system guarantees these are dictionaries based on _process_hetero_nodes
@@ -601,8 +601,6 @@ def _process_hetero_edges(
                 )
                 data[edge_type].edge_index = edge_index
 
-                data[edge_type].edge_index = edge_index
-
                 feature_cols = edge_feature_cols.get(edge_type) if edge_feature_cols else None
                 data[edge_type].edge_attr = self._create_features(edge_gdf, feature_cols)
             else:
@@ -858,7 +856,7 @@ def _reconstruct_node_gdf(
         else:
             # Handle missing geometry
             length = len(next(iter(gdf_data.values()))) if gdf_data else 0
-            empty_geom = gpd.GeoSeries([None] * length, crs=metadata.crs if metadata.crs else None)
+            empty_geom = gpd.GeoSeries([None] * length, crs=metadata.crs or None)
             gdf = gpd.GeoDataFrame(gdf_data, geometry=empty_geom, index=index_values)
 
         # Set index names and CRS
@@ -937,7 +935,7 @@ def _reconstruct_edge_gdf(
         else:
             # Handle missing geometry
             length = len(next(iter(gdf_data.values()))) if gdf_data else 0
-            empty_geom = gpd.GeoSeries([None] * length, crs=metadata.crs if metadata.crs else None)
+            empty_geom = gpd.GeoSeries([None] * length, crs=metadata.crs or None)
             gdf = gpd.GeoDataFrame(gdf_data, geometry=empty_geom, index=index_values)
 
         # Set index names and CRS

city2graph/metapath.py

@@ -259,7 +259,7 @@ def add_metapaths_by_weight(  # noqa: PLR0913
 
     # Prepare data for sparse matrix construction
     (
-        node_to_idx,
+        _node_to_idx,
         idx_to_node,
         endpoint_indices,
         row_indices,
@@ -983,7 +983,7 @@ def _empty_metapath_frame(
     pandas.DataFrame
         Empty DataFrame with the requested columns and index structure.
     """
-    columns = ["weight"] + (edge_attrs if edge_attrs else [])
+    columns = ["weight"] + (edge_attrs or [])
     frame = pd.DataFrame(columns=columns)
     frame.index = pd.MultiIndex.from_tuples([], names=[start_index_name, end_index_name])
     return frame

city2graph/morphology.py

@@ -806,7 +806,7 @@ def _validate_input_gdfs(buildings_gdf: gpd.GeoDataFrame, segments_gdf: gpd.GeoD
     if not segments_gdf.empty:
         # Assuming LineString is required for operations like dual_graph
         segment_geom_types = segments_gdf.geometry.geom_type.unique()
-        if not all(geom_type in {"LineString"} for geom_type in segment_geom_types):
+        if not all(geom_type == "LineString" for geom_type in segment_geom_types):
             msg = (
                 f"segments_gdf must contain only LineString geometries. "
                 f"Found: {', '.join(segment_geom_types)}"

city2graph/utils.py

@@ -1785,7 +1785,7 @@ def dual_graph(
     >>> dual_nodes, dual_edges = dual_graph((nodes, edges))
     """
     # Validate input type and extract GeoDataFrames
-    nodes_gdf, edges_gdf = _validate_dual_graph_input(graph)
+    _nodes_gdf, edges_gdf = _validate_dual_graph_input(graph)
 
     # Ensure edges have a CRS
     if edges_gdf.crs is None:

tests/test_data.py

@@ -180,7 +180,7 @@ def test_invalid_release(self, test_bbox: list[float]) -> None:
             ),
             pytest.raises(
                 ValueError,
-                match="Invalid release: 2099-99-99.0. Valid releases are: 2025-08-20.0, 2025-08-20.1, 2025-09-24.0",
+                match=r"Invalid release: 2099-99-99.0. Valid releases are: 2025-08-20.0, 2025-08-20.1, 2025-09-24.0",
             ),
         ):
             load_overture_data(test_bbox, types=["building"], release=invalid_release)

tests/test_graph.py

@@ -656,13 +656,13 @@ def test_tensor_validation_errors(self, sample_nodes_gdf: gpd.GeoDataFrame) -> N
         # Position tensor mismatch
         data = gdf_to_pyg(sample_nodes_gdf)
         data.pos = torch.randn(1, 2)  # Wrong size
-        with pytest.raises(ValueError, match="position tensor size.*doesn't match"):
+        with pytest.raises(ValueError, match=r"position tensor size.*doesn't match"):
             validate_pyg(data)
 
         # Label tensor mismatch
         data = gdf_to_pyg(sample_nodes_gdf, node_label_cols=["label1"])
         data.y = torch.randn(1, 1)  # Wrong size
-        with pytest.raises(ValueError, match="label tensor size.*doesn't match"):
+        with pytest.raises(ValueError, match=r"label tensor size.*doesn't match"):
             validate_pyg(data)
 
     def test_hetero_label_tensor_mismatch(
@@ -681,7 +681,7 @@ def test_hetero_label_tensor_mismatch(
 
         with pytest.raises(
             ValueError,
-            match="Node type 'building': label tensor size.*doesn't match",
+            match=r"Node type 'building': label tensor size.*doesn't match",
         ):
             validate_pyg(data)
 
@@ -722,15 +722,15 @@ def test_homo_edge_validation_cases(
         data.edge_attr = torch.randn(2, 1)  # Wrong size
         with pytest.raises(
             ValueError,
-            match="Edge attribute tensor size.*doesn't match number of edges",
+            match=r"Edge attribute tensor size.*doesn't match number of edges",
         ):
             validate_pyg(data)
 
     def test_heterogeneous_tensor_validation(self, sample_pyg_hetero_data: HeteroData) -> None:
         """Test tensor validation for heterogeneous graphs."""
         node_type = next(iter(sample_pyg_hetero_data.node_types))
         sample_pyg_hetero_data[node_type].pos = torch.randn(1, 2)  # Wrong size
-        with pytest.raises(ValueError, match="position tensor size.*doesn't match"):
+        with pytest.raises(ValueError, match=r"position tensor size.*doesn't match"):
             validate_pyg(sample_pyg_hetero_data)
 
     def test_homogeneous_validation_errors(self, sample_nodes_gdf: gpd.GeoDataFrame) -> None:

tests/test_metapath.py

@@ -359,7 +359,7 @@ def test_add_metapaths_edge_direction_and_lookup(
             assert ("road", "metapath_0", "road") in edges_rev
         else:
             bad_mp = [("x", "y", "z"), ("z", "y", "x")]
-            with pytest.raises(KeyError, match="Edge type .* not found"):
+            with pytest.raises(KeyError, match=r"Edge type .* not found"):
                 add_metapaths(
                     (sample_hetero_nodes_dict, sample_hetero_edges_dict),
                     sequence=bad_mp,

tests/test_mobility.py

@@ -57,7 +57,7 @@ def test_edgelist_multi_weight_threshold_col(self, od_zones_gdf: gpd.GeoDataFram
                 "w2": [10, 0, 2],
             }
         )
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             od_zones_gdf,
             zone_id_col="zone_id",
@@ -112,7 +112,7 @@ def test_undirected_sums_reciprocals_edgelist(self, od_zones_gdf: gpd.GeoDataFra
                 "flow": [3, 2, 1, 4],
             }
         )
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             od_zones_gdf,
             zone_id_col="zone_id",
@@ -137,7 +137,7 @@ def test_undirected_threshold_after_sum(self, od_zones_gdf: gpd.GeoDataFrame) ->
                 "flow": [1, 1, 1],
             }
         )
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             od_zones_gdf,
             zone_id_col="zone_id",
@@ -269,7 +269,7 @@ def test_include_self_loops_adjacency_and_nan_negative(
             index=od_zones_gdf["zone_id"],
             columns=od_zones_gdf["zone_id"],
         )
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             A,
             od_zones_gdf,
             zone_id_col="zone_id",
@@ -287,7 +287,7 @@ def test_align_edgelist_drops_unknown_and_no_overlap_raises(
         """Unknown IDs are dropped; if nothing remains, ValueError is raised."""
         # One valid, one invalid edge -> should drop invalid
         E = pd.DataFrame({"source": ["A", "X"], "target": ["B", "A"], "flow": [1, 3]})
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             od_zones_gdf,
             zone_id_col="zone_id",
@@ -316,7 +316,7 @@ def test_empty_after_threshold_yields_empty_edgeframe_schema(
     ) -> None:
         """High threshold removes all edges but preserves schema columns."""
         E = pd.DataFrame({"source": ["A"], "target": ["B"], "w1": [1], "w2": [5]})
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             od_zones_gdf,
             zone_id_col="zone_id",
@@ -332,7 +332,7 @@ def test_empty_after_threshold_yields_empty_edgeframe_schema(
     def test_undirected_with_self_loop_preserved(self, od_zones_gdf: gpd.GeoDataFrame) -> None:
         """In undirected mode, self-loops are preserved as-is after symmetrization."""
         E = pd.DataFrame({"source": ["A", "A"], "target": ["A", "B"], "flow": [2, 3]})
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             od_zones_gdf,
             zone_id_col="zone_id",
@@ -495,7 +495,7 @@ def test_missing_centroid_edges_dropped_in_geometry_creation(
         zones = od_zones_gdf.copy()
         zones.loc[1, "geometry"] = None  # make B missing
         E = pd.DataFrame({"source": ["A", "B"], "target": ["B", "A"], "flow": [1, 2]})
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             zones,
             zone_id_col="zone_id",
@@ -515,7 +515,7 @@ def test_adjacency_all_zero_results_in_empty_edges(
         A = pd.DataFrame(
             np.zeros((3, 3)), index=od_zones_gdf["zone_id"], columns=od_zones_gdf["zone_id"]
         )
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             A, od_zones_gdf, zone_id_col="zone_id", matrix_type="adjacency"
         )
         assert edges.empty
@@ -585,7 +585,7 @@ def test_weight_column_nan_and_negative_handling(self, od_zones_gdf: gpd.GeoData
                 "flow": [np.nan, -1, 0.5, 0],
             }
         )
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E, od_zones_gdf, zone_id_col="zone_id", matrix_type="edgelist", weight_cols=["flow"]
         )
         # NaN->0 then drop zeros; negative retained but threshold None drops values <=0
@@ -596,7 +596,7 @@ def test_weight_column_nan_and_negative_handling(self, od_zones_gdf: gpd.GeoData
     def test_self_loop_removed_when_not_included(self, od_zones_gdf: gpd.GeoDataFrame) -> None:
         """Self-loop is removed by default include_self_loops=False."""
         E = pd.DataFrame({"source": ["A", "A"], "target": ["A", "B"], "flow": [5, 1]})
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             od_zones_gdf,
             zone_id_col="zone_id",
@@ -616,7 +616,7 @@ def test_align_adjacency_partial_overlap_warns_and_reindexes(
             index=["A", "B", "X"],
             columns=["A", "B", "X"],
         )
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             A, od_zones_gdf, zone_id_col="zone_id", matrix_type="adjacency"
         )
         # Only edges among A,B retained
@@ -630,7 +630,7 @@ def test_missing_crs_emits_warning(self, od_zones_gdf: gpd.GeoDataFrame) -> None
         # Remove CRS in a version-robust way (GeoPandas requires allow_override when overriding)
         zones = zones.set_crs(None, allow_override=True)
         E = pd.DataFrame({"source": ["A"], "target": ["B"], "flow": [1]})
-        nodes, edges = od_matrix_to_graph(
+        nodes, _edges = od_matrix_to_graph(
             E,
             zones,
             zone_id_col="zone_id",
@@ -682,7 +682,7 @@ def test_undirected_multi_weight_sums_all_columns(self, od_zones_gdf: gpd.GeoDat
                 "w2": [10, 20, 30, 40],
             }
         )
-        nodes, edges = od_matrix_to_graph(
+        _nodes, edges = od_matrix_to_graph(
             E,
             od_zones_gdf,
             zone_id_col="zone_id",

tests/test_morphology.py

@@ -247,7 +247,7 @@ def test_negative_parameters(
         Point(0, 0)
 
         # Test negative clipping buffer (this should raise ValueError)
-        with pytest.raises(ValueError, match="clipping_buffer cannot be negative."):
+        with pytest.raises(ValueError, match=r"clipping_buffer cannot be negative."):
             morphological_graph(
                 sample_buildings_gdf,
                 sample_segments_gdf,
@@ -433,7 +433,7 @@ def test_public_to_public_networkx(self, sample_segments_gdf: gpd.GeoDataFrame)
 
     def test_public_to_public_edge_structure(self, sample_segments_gdf: gpd.GeoDataFrame) -> None:
         """Test public-to-public edge structure."""
-        nodes, edges = public_to_public_graph(sample_segments_gdf)
+        _nodes, edges = public_to_public_graph(sample_segments_gdf)
         self.validate_edge_columns(edges, ["from_public_id", "to_public_id"])
 
     def test_public_to_public_multiindex_handling(self, sample_crs: str) -> None:

tests/test_proximity.py

@@ -310,7 +310,7 @@ def test_group_nodes_predicate_alias_within() -> None:
     """Predicate 'within' excludes boundary point so only interior point remains."""
     polys, pts = make_poly_points_pair()
     # Shift third point to be strictly outside
-    nodes, edges = group_nodes(polys, pts, predicate="within")
+    _nodes, edges = group_nodes(polys, pts, predicate="within")
     edge_key = next(iter(edges))
     # Points 1 only strictly within (point 2 is on boundary so excluded for within)
     e = edges[edge_key]
@@ -361,7 +361,7 @@ class TestContiguityPublicAPI:
     def test_small_grid(self) -> None:
         """Smoke test small grid contiguity output symmetry."""
         gdf = make_square_polygons()
-        nodes, edges = contiguity_graph(gdf)
+        nodes, _edges = contiguity_graph(gdf)
         assert set(nodes.index) == set(gdf.index)
         # Edges GeoDataFrame stores undirected edges once (u,v where u<v maybe);
         # validate symmetry by converting to networkx graph and checking neighbors.
@@ -422,7 +422,7 @@ def test_delaunay_network_metric(
     network_edges: gpd.GeoDataFrame, small_points: gpd.GeoDataFrame
 ) -> None:
     """Delaunay with network metric attaches network-based weights/geometries."""
-    nodes, edges = delaunay_graph(
+    _nodes, edges = delaunay_graph(
         small_points, distance_metric="network", network_gdf=network_edges
     )
     if len(small_points) >= 3:
@@ -451,7 +451,7 @@ def test_mst_network_metric(
     network_edges: gpd.GeoDataFrame, small_points: gpd.GeoDataFrame
 ) -> None:
     """Minimum spanning tree under network metric (complete graph fallback)."""
-    nodes, edges = euclidean_minimum_spanning_tree(
+    _nodes, edges = euclidean_minimum_spanning_tree(
         small_points, distance_metric="network", network_gdf=network_edges
     )
     # Tree edges <= n-1
@@ -470,7 +470,7 @@ def test_fixed_radius_network_metric(
 
 def test_waxman_basic(small_points: gpd.GeoDataFrame) -> None:
     """Waxman graph probabilistic construction (schema validation)."""
-    nodes, edges = waxman_graph(small_points, beta=0.5, r0=3.0, seed=123)
+    _nodes, edges = waxman_graph(small_points, beta=0.5, r0=3.0, seed=123)
     assert set(edges.columns) >= {"weight", "geometry"}
 
 
@@ -571,7 +571,7 @@ def test_group_nodes_network_metric_success() -> None:
         lines.append(LineString([poly_centroid, p]))
     mi = pd.MultiIndex.from_arrays([src, dst], names=("source_id", "target_id"))
     net = gpd.GeoDataFrame({"geometry": lines}, index=mi, crs=polys.crs)
-    nodes, edges = group_nodes(polys, pts, distance_metric="network", network_gdf=net)
+    _nodes, edges = group_nodes(polys, pts, distance_metric="network", network_gdf=net)
     edge_key = next(iter(edges))
     e = edges[edge_key]
     assert len(e) == 2  # two contained points
@@ -593,7 +593,7 @@ def test_group_nodes_network_with_length_weight() -> None:
         lengths.append(seg.length)
     mi = pd.MultiIndex.from_arrays([src, dst], names=("source_id", "target_id"))
     net = gpd.GeoDataFrame({"length": lengths, "geometry": lines}, index=mi, crs=polys.crs)
-    nodes, edges = group_nodes(polys, pts, distance_metric="network", network_gdf=net)
+    _nodes, edges = group_nodes(polys, pts, distance_metric="network", network_gdf=net)
     edge_key = next(iter(edges))
     e = edges[edge_key]
     assert len(e) == 2
@@ -613,7 +613,7 @@ def test_group_nodes_no_matches_nonempty() -> None:
         geometry=[Point(0, 0), Point(1, 1)],
         crs="EPSG:3857",
     ).set_index("pid")
-    nodes, edges = group_nodes(polys, pts)
+    _nodes, edges = group_nodes(polys, pts)
     edge_key = next(iter(edges))
     assert edges[edge_key].empty
 
@@ -650,7 +650,7 @@ def test_contiguity_network_metric_success() -> None:
         index=pd.MultiIndex.from_arrays([[0], [1]], names=("source_id", "target_id")),
         crs=gdf.crs,
     )
-    nodes, edges = contiguity_graph(gdf, distance_metric="network", network_gdf=net)
+    _nodes, edges = contiguity_graph(gdf, distance_metric="network", network_gdf=net)
     assert len(edges) == 1
 
 
@@ -681,7 +681,7 @@ def test_contiguity_network_length_weight_branch() -> None:
         index=pd.MultiIndex.from_arrays([[0], [1]], names=("source_id", "target_id")),
         crs=gdf.crs,
     )
-    nodes, edges = contiguity_graph(gdf, distance_metric="network", network_gdf=net)
+    _nodes, edges = contiguity_graph(gdf, distance_metric="network", network_gdf=net)
     assert len(edges) == 1
     # Ensure geometry and weight present (path weight via 'length')
     assert set(edges.columns) >= {"weight", "geometry"}