ruff

soodoku · soodoku · commit 06c55bdcbcd8 · 2025-12-07T23:30:37.000-08:00
diff --git a/allocator/core/algorithms.py b/allocator/core/algorithms.py
@@ -13,6 +13,7 @@
 try:
     from sklearn.cluster import KMeans
     from sklearn.utils.validation import check_array
+
     HAS_SKLEARN = True
 except ImportError:
     HAS_SKLEARN = False
@@ -70,7 +71,14 @@ class CustomKMeans(KMeans if HAS_SKLEARN else object):
     including haversine, OSRM, and Google Maps API distances.
     """
 
-    def __init__(self, n_clusters=8, distance_method="euclidean", max_iter=300, random_state=None, **distance_kwargs):
+    def __init__(
+        self,
+        n_clusters=8,
+        distance_method="euclidean",
+        max_iter=300,
+        random_state=None,
+        **distance_kwargs,
+    ):
         if HAS_SKLEARN:
             # Initialize sklearn KMeans with all parameters
             super().__init__(n_clusters=n_clusters, max_iter=max_iter, random_state=random_state)
@@ -81,12 +89,14 @@ def __init__(self, n_clusters=8, distance_method="euclidean", max_iter=300, rand
     def _transform(self, X):
         """Override sklearn's distance calculation to use custom metrics."""
         if not HAS_SKLEARN:
-            raise ImportError("sklearn is required for CustomKMeans. Install with: pip install 'allocator[algorithms]'")
+            raise ImportError(
+                "sklearn is required for CustomKMeans. Install with: pip install 'allocator[algorithms]'"
+            )
 
         # Use our custom distance factory instead of sklearn's euclidean
-        distances = get_distance_matrix(X, self.cluster_centers_,
-                                      method=self.distance_method,
-                                      **self.distance_kwargs)
+        distances = get_distance_matrix(
+            X, self.cluster_centers_, method=self.distance_method, **self.distance_kwargs
+        )
         return distances
 
     def _update_centroids(self, X, labels):
@@ -111,17 +121,17 @@ def fit(self, X, y=None, sample_weight=None):
             # Fallback to original implementation if sklearn not available
             return self._fit_custom_implementation(X)
 
-        X = check_array(X, accept_sparse='csr', dtype=[np.float64, np.float32])
+        X = check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
 
         # Initialize using sklearn's initialization logic
         super().fit(X)
 
         # Now run our custom iterations
         for iteration in range(self.max_iter):
             # Calculate distances using custom metric
-            distances = get_distance_matrix(X, self.cluster_centers_,
-                                          method=self.distance_method,
-                                          **self.distance_kwargs)
+            distances = get_distance_matrix(
+                X, self.cluster_centers_, method=self.distance_method, **self.distance_kwargs
+            )
 
             # Assign points to nearest centroids
             labels = np.argmin(distances, axis=1)
@@ -145,9 +155,9 @@ def fit(self, X, y=None, sample_weight=None):
 
     def _fit_custom_implementation(self, X):
         """Fallback to original implementation when sklearn is not available."""
-        result = _kmeans_cluster_original(X, self.n_clusters,
-                                        distance_method=self.distance_method,
-                                        **self.distance_kwargs)
+        result = _kmeans_cluster_original(
+            X, self.n_clusters, distance_method=self.distance_method, **self.distance_kwargs
+        )
         self.cluster_centers_ = result["centroids"]
         self.labels_ = result["labels"]
         self.n_iter_ = result["iterations"]
@@ -184,7 +194,7 @@ def kmeans_cluster(
             distance_method=distance_method,
             max_iter=max_iter,
             random_state=random_state,
-            **distance_kwargs
+            **distance_kwargs,
         )
         kmeans.fit(X)
 
@@ -196,7 +206,9 @@ def kmeans_cluster(
         }
 
     # Fall back to original implementation
-    return _kmeans_cluster_original(X, n_clusters, distance_method, max_iter, random_state, **distance_kwargs)
+    return _kmeans_cluster_original(
+        X, n_clusters, distance_method, max_iter, random_state, **distance_kwargs
+    )
 
 
 def _kmeans_cluster_original(
diff --git a/allocator/viz/plotting.py b/allocator/viz/plotting.py
@@ -12,12 +12,14 @@
 try:
     import folium
     from folium import plugins
+
     HAS_FOLIUM = True
 except ImportError:
     HAS_FOLIUM = False
 
 try:
     import polyline
+
     HAS_POLYLINE = True
 except ImportError:
     HAS_POLYLINE = False
@@ -277,18 +279,26 @@ def plot_clusters_interactive(
         zoom_start = 8
 
     # Create base map
-    m = folium.Map(
-        location=[center_lat, center_lon],
-        zoom_start=zoom_start,
-        tiles='OpenStreetMap'
-    )
+    m = folium.Map(location=[center_lat, center_lon], zoom_start=zoom_start, tiles="OpenStreetMap")
 
     # Color palette for clusters
     n_clusters = len(np.unique(labels))
     color_palette = [
-        '#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FECA57',
-        '#FF9FF3', '#54A0FF', '#5F27CD', '#00D2D3', '#FF9F43',
-        '#A55EEA', '#26DE81', '#FD79A8', '#FDCB6E', '#6C5CE7'
+        "#FF6B6B",
+        "#4ECDC4",
+        "#45B7D1",
+        "#96CEB4",
+        "#FECA57",
+        "#FF9FF3",
+        "#54A0FF",
+        "#5F27CD",
+        "#00D2D3",
+        "#FF9F43",
+        "#A55EEA",
+        "#26DE81",
+        "#FD79A8",
+        "#FDCB6E",
+        "#6C5CE7",
     ]
 
     # Extend palette if needed
@@ -304,10 +314,10 @@ def plot_clusters_interactive(
             location=[lat, lon],
             radius=6,
             popup=f"Point {i}<br>Cluster: {cluster_id}<br>Coords: ({lon:.4f}, {lat:.4f})",
-            color='white',
+            color="white",
             weight=1,
             fillColor=color,
-            fillOpacity=0.8
+            fillOpacity=0.8,
         ).add_to(m)
 
     # Add centroids if provided
@@ -317,8 +327,8 @@ def plot_clusters_interactive(
             folium.Marker(
                 location=[lat, lon],
                 popup=f"Centroid {k}<br>Coords: ({lon:.4f}, {lat:.4f})",
-                icon=folium.Icon(color='black', icon='star', prefix='fa'),
-                tooltip=f"Cluster {k} Centroid"
+                icon=folium.Icon(color="black", icon="star", prefix="fa"),
+                tooltip=f"Cluster {k} Centroid",
             ).add_to(m)
 
     # Add legend
@@ -337,7 +347,7 @@ def plot_clusters_interactive(
         legend_html += f'<p><span style="color:{color};">●</span> Cluster {k}</p>'
 
     if n_clusters > 8:
-        legend_html += f'<p>... and {n_clusters - 8} more</p>'
+        legend_html += f"<p>... and {n_clusters - 8} more</p>"
 
     legend_html += "</div>"
     m.get_root().html.add_child(folium.Element(legend_html))
@@ -403,11 +413,7 @@ def plot_route_interactive(
         zoom_start = 8
 
     # Create base map
-    m = folium.Map(
-        location=[center_lat, center_lon],
-        zoom_start=zoom_start,
-        tiles='OpenStreetMap'
-    )
+    m = folium.Map(location=[center_lat, center_lon], zoom_start=zoom_start, tiles="OpenStreetMap")
 
     # Add route line
     if route_geometry and HAS_POLYLINE:
@@ -418,11 +424,7 @@ def plot_route_interactive(
             route_coords = [[lat, lon] for lat, lon in decoded_coords]
 
             folium.PolyLine(
-                locations=route_coords,
-                color='blue',
-                weight=4,
-                opacity=0.8,
-                popup="Optimized Route"
+                locations=route_coords, color="blue", weight=4, opacity=0.8, popup="Optimized Route"
             ).add_to(m)
         except Exception:
             # Fall back to straight line connections if decoding fails
@@ -437,23 +439,23 @@ def plot_route_interactive(
 
         # Color-code start, end, and intermediate points
         if i == 0:
-            icon_color = 'green'
-            icon_symbol = 'play'
-            label = 'Start'
+            icon_color = "green"
+            icon_symbol = "play"
+            label = "Start"
         elif i == len(route_order) - 1:
-            icon_color = 'red'
-            icon_symbol = 'stop'
-            label = 'End'
+            icon_color = "red"
+            icon_symbol = "stop"
+            label = "End"
         else:
-            icon_color = 'blue'
-            icon_symbol = f'{i}'
-            label = f'Stop {i}'
+            icon_color = "blue"
+            icon_symbol = f"{i}"
+            label = f"Stop {i}"
 
         folium.Marker(
             location=[lat, lon],
             popup=f"{label}<br>Point {point_idx}<br>Coords: ({lon:.4f}, {lat:.4f})",
-            icon=folium.Icon(color=icon_color, icon=icon_symbol, prefix='fa'),
-            tooltip=f"{label} (Point {point_idx})"
+            icon=folium.Icon(color=icon_color, icon=icon_symbol, prefix="fa"),
+            tooltip=f"{label} (Point {point_idx})",
         ).add_to(m)
 
     # Calculate route statistics
@@ -467,7 +469,7 @@ def plot_route_interactive(
                 font-size:14px; padding: 10px">
     <h4>{title}</h4>
     <p><strong>Points:</strong> {len(route_points)}</p>
-    <p><strong>Route Type:</strong> {'API Route' if route_geometry else 'Direct Lines'}</p>
+    <p><strong>Route Type:</strong> {"API Route" if route_geometry else "Direct Lines"}</p>
     <p><strong>Est. Distance:</strong> {total_distance:.2f} km</p>
     <hr>
     <p><span style="color:green;">●</span> Start Point</p>
@@ -487,7 +489,9 @@ def plot_route_interactive(
     return m
 
 
-def _add_straight_line_route(m: folium.Map, route_points: np.ndarray, route_order: list[int]) -> None:
+def _add_straight_line_route(
+    m: folium.Map, route_points: np.ndarray, route_order: list[int]
+) -> None:
     """Add straight line connections between route points."""
     ordered_points = route_points[route_order]
 
@@ -497,10 +501,10 @@ def _add_straight_line_route(m: folium.Map, route_points: np.ndarray, route_orde
 
     folium.PolyLine(
         locations=route_coords,
-        color='blue',
+        color="blue",
         weight=3,
         opacity=0.7,
-        popup="Direct Route (Straight Lines)"
+        popup="Direct Route (Straight Lines)",
     ).add_to(m)
 
 
@@ -516,7 +520,7 @@ def haversine_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> fl
         # Haversine formula
         dlat = lat2 - lat1
         dlon = lon2 - lon1
-        a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
+        a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
         c = 2 * asin(sqrt(a))
 
         # Earth radius in kilometers
@@ -532,8 +536,10 @@ def haversine_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> fl
         next_point = ordered_points[(i + 1) % len(ordered_points)]  # Return to start
 
         distance = haversine_distance(
-            current_point[1], current_point[0],  # lat1, lon1
-            next_point[1], next_point[0]         # lat2, lon2
+            current_point[1],
+            current_point[0],  # lat1, lon1
+            next_point[1],
+            next_point[0],  # lat2, lon2
         )
         total_distance += distance
 
diff --git a/tests/api/test_cluster_api.py b/tests/api/test_cluster_api.py
@@ -91,8 +91,10 @@ def test_kmeans_reproducibility(self):
         labels_identical = np.array_equal(result1.labels, result2.labels)
         labels_flipped = np.array_equal(result1.labels, 1 - result2.labels)
 
-        self.assertTrue(labels_identical or labels_flipped,
-                       "Clustering results should be reproducible (labels may be flipped)")
+        self.assertTrue(
+            labels_identical or labels_flipped,
+            "Clustering results should be reproducible (labels may be flipped)",
+        )
 
         # Centroids should be the same (possibly in different order)
         centroids1_sorted = np.sort(result1.centroids.flatten())
