""" Google Maps API Service """ import requests from typing import List, Dict, Any, Optional, Tuple, Union from datetime import datetime, timedelta, timezone import numpy as np import time from src.infra.logger import get_logger logger = get_logger(__name__) MAX_LOCATIONS_PER_SIDE = 50 def cleanup_str(key: str) -> str: return key.strip('\'" ') def clean_dict_list_keys(data_list: List[Dict[str, Any]]) -> List[Dict[str, Any]]: if not isinstance(data_list, list): # 為了安全，如果輸入不是列表，直接返回原始輸入或空列表 print(f"Warning: Input is not a list. Received type: {type(data_list)}") return data_list cleaned_list = [] for item in data_list: if isinstance(item, dict): cleaned_item = {} for original_key, value in item.items(): new_key = cleanup_str(original_key) cleaned_item[new_key] = value cleaned_list.append(cleaned_item) else: cleaned_list.append(item) return cleaned_list class GoogleMapAPIService: def __init__(self, api_key: str = None): """ Initialize Google Maps API service Args: api_key: Google Maps API key (required) """ if api_key: self.api_key = api_key else: import os self.api_key = os.getenv("GOOGLE_MAPS_API_KEY") try: from src.infra.config import get_settings settings = get_settings() self.api_key = settings.google_maps_api_key except (ImportError, AttributeError) as e: raise e if not self.api_key: raise ValueError( "Google Maps API key is required. " "Set via parameter, config, or GOOGLE_MAPS_API_KEY env var" ) # API endpoints self.geolocation_url = "https://www.googleapis.com/geolocation/v1/geolocate" self.places_text_search_url = "https://places.googleapis.com/v1/places:searchText" self.compute_routes_url = "https://routes.googleapis.com/directions/v2:computeRoutes" self.compute_route_matrix_url = "https://routes.googleapis.com/distanceMatrix/v2:computeRouteMatrix" logger.info("✅ Google Maps API service initialized") # ======================================================================== # Geolocation # ======================================================================== def current_location(self) -> Dict[str, Any]: """ Get current location using Geolocation API Returns: Location info with lat/lng Raises: requests.RequestException: If API request fails """ try: response = requests.post( self.geolocation_url, params={"key": self.api_key}, headers={"Content-Type": "application/json"}, timeout=10 ) if not response.ok: logger.error(f"❌ Geolocation API error: {response.text}") response.raise_for_status() data = response.json() # ✅ 改進: 檢查響應有效性 if "location" not in data: raise ValueError("Invalid geolocation response") logger.debug(f"📍 Current location: {data['location']}") return data except requests.Timeout: logger.error("⏰ Geolocation request timeout") raise except requests.RequestException as e: logger.error(f"❌ Geolocation request failed: {e}") raise except Exception as e: logger.error(f"❌ Unexpected error in current_location: {e}") raise # ======================================================================== # Places API - Text Search (New API v1) # ======================================================================== def text_search( self, query: str, location: Optional[Dict[str, float]] = None, radius: Optional[int] = 10000, limit: int = 3, ) -> List[Dict[str, Any]]: """ Search for a place to get its coordinates and details. Use this to convert a user's vague query (e.g., "Gas station", "Taipei 101") into precise lat/lng coordinates. Args: query: The search text (e.g., "Din Tai Fung", "Hospital"). location: Optional bias location {"lat": float, "lng": float}. radius: Search radius in meters (optional). limit: Max results to return (default 3). Returns: List[Dict]: A list of places found. Each item contains: - name: str - address: str - location: {"lat": float, "lng": float} (CRITICAL for routing) - place_id: str - rating: float """ request_body = { "textQuery": query, "maxResultCount": min(limit, 20) } if location and radius: request_body["locationBias"] = { "circle": { "center": { "latitude": location["lat"], "longitude": location["lng"] }, "radius": float(radius) } } headers = { "Content-Type": "application/json", "X-Goog-Api-Key": self.api_key, "X-Goog-FieldMask": ( "places.id," "places.displayName," "places.formattedAddress," "places.location," "places.rating," "places.userRatingCount," "places.businessStatus," "places.currentOpeningHours," ) } try: logger.debug(f"🔍 Searching places: '{query}', cent_location:'{location}'(limit={limit})") response = requests.post( self.places_text_search_url, json=request_body, headers=headers, timeout=10 ) if not response.ok: print(f"❌ Places Text Search API error: {response.text}") response.raise_for_status() data = response.json() places = data.get("places", []) if not places: logger.warning(f"⚠️ No places found for query: '{query}'") return [] logger.info(f"✅ Found {len(places)} places for '{query}'") standardized_places = [] for place in places: standardized_places.append({ "place_id": place.get("id"), "name": place.get("displayName", {}).get("text", "Unknown"), "address": place.get("formattedAddress", ""), "location": place.get("location", {}), "rating": place.get("rating"), "user_ratings_total": place.get("userRatingCount", 0), "business_status": place.get("businessStatus", "UNKNOWN"), "opening_hours": place.get("currentOpeningHours", {}) }) return standardized_places except requests.Timeout: logger.error("⏰ Places search timeout") raise except requests.RequestException as e: logger.error(f"❌ Places search failed: {e}") raise except Exception as e: logger.error(f"❌ Unexpected error in text_search: {e}") raise # ======================================================================== # Routes API - Compute Routes # ======================================================================== def _compute_routes( self, origin: Dict[str, Any], destination: Dict[str, Any], waypoints: Optional[List[Dict[str, float]]] = None, travel_mode: str = "DRIVE", routing_preference: str = "TRAFFIC_AWARE_OPTIMAL", compute_alternative_routes: bool = False, optimize_waypoint_order: bool = False, departure_time: Optional[datetime] = None, include_traffic_on_polyline: bool = True ) -> Dict[str, Any]: """ ✅ P0-1 & P0-3 修復: 正確的經緯度 + 完整的響應解析 Internal method to compute routes using Routes API v2 Args: origin: Origin location dict with 'lat' and 'lng' keys destination: Destination location dict with 'lat' and 'lng' keys waypoints: Optional list of waypoint dicts with 'lat' and 'lng' travel_mode: Travel mode (DRIVE, WALK, BICYCLE, TRANSIT) routing_preference: Routing preference compute_alternative_routes: Whether to compute alternatives optimize_waypoint_order: Whether to optimize waypoint order departure_time: Departure time as datetime object include_traffic_on_polyline: Whether to include traffic info Returns: Parsed route information dict with: - distance_meters: int - duration_seconds: int - encoded_polyline: str - legs: List[Dict] - optimized_waypoint_order: Optional[List[int]] Raises: ValueError: If route cannot be computed requests.RequestException: If API request fails """ # ✅ P0-1 修復: 正確使用 lng 而不是 lat request_body = { "origin": { "location": { "placeId": origin["place_id"] } if "place_id" in origin else { "latLng": { "latitude": origin["lat"], "longitude": origin["lng"] } } }, "destination": { "location": { "placeId": destination["place_id"] } if "place_id" in destination else { "latLng": { "latitude": destination["lat"], "longitude": destination["lng"] } } }, "travelMode": travel_mode, "routingPreference": routing_preference, "computeAlternativeRoutes": compute_alternative_routes, "languageCode": "zh-TW", "units": "METRIC" } # ✅ 添加中間點 if waypoints: request_body["intermediates"] = [ { "location": { "latLng": { "latitude": wp["lat"], "longitude": wp["lng"] } } } for wp in waypoints ] if optimize_waypoint_order: request_body["optimizeWaypointOrder"] = True if departure_time: if isinstance(departure_time, datetime): request_body["departureTime"] = departure_time.isoformat() elif departure_time == "now": request_body["departureTime"] = datetime.now(timezone.utc).isoformat() # ✅ Field Mask field_mask_parts = [ "routes.duration", "routes.distanceMeters", "routes.polyline.encodedPolyline", "routes.legs", "routes.optimizedIntermediateWaypointIndex" ] if include_traffic_on_polyline: field_mask_parts.extend([ "routes.travelAdvisory", "routes.legs.travelAdvisory" ]) field_mask = ",".join(field_mask_parts) headers = { "Content-Type": "application/json", "X-Goog-Api-Key": self.api_key, "X-Goog-FieldMask": field_mask } logger.debug( f"🗺️ Computing route: {origin['lat']:.4f},{origin['lng']:.4f} → " f"{destination['lat']:.4f},{destination['lng']:.4f}, {request_body['travelMode']} " f"({len(waypoints) if waypoints else 0} waypoints)" ) try: response = requests.post( self.compute_routes_url, json=request_body, headers=headers, timeout=30 # ✅ 增加超時時間 ) if not response.ok: logger.error(f"❌ Routes API error: {response.text}") response.raise_for_status() data = response.json() if hasattr(response, 'json'): try: data = response.json() # 📦 拆開包裹，取得字典資料 except ValueError: print("❌ API 回傳的內容不是有效的 JSON") data = {} # 如果它已經是 list 或 dict (例如某些 client library 會自動轉)，就直接用 elif isinstance(response, (dict, list)): data = response else: # 防呆：未知的格式 data = {} # [轉接] 確保格式符合 Parser 需求 (Google Maps API 通常回傳 dict，但也可能包在 list 裡) if isinstance(data, list): formatted_response = {"routes": data} else: formatted_response = data if "routes" not in data or not data["routes"]: logger.error("❌ No routes found in API response") raise ValueError("No routes found") route = data["routes"][0] distance_meters = route.get("distanceMeters", 0) duration_str = route.get("duration", "0s") duration_seconds = int(duration_str.rstrip("s")) polyline_data = route.get("polyline", {}) encoded_polyline = polyline_data.get("encodedPolyline", "") legs = route.get("legs", []) optimized_order = route.get("optimizedIntermediateWaypointIndex") result = { "distance_meters": distance_meters, "duration_seconds": duration_seconds, "encoded_polyline": encoded_polyline, "legs": legs, "optimized_waypoint_order": optimized_order } logger.debug( f"✅ Route computed: {distance_meters}m, {duration_seconds}s" ) return result except requests.Timeout: logger.error("⏰ Routes request timeout") raise except requests.RequestException as e: logger.error(f"❌ Routes request failed: {e}") raise except (KeyError, ValueError) as e: logger.error(f"❌ Failed to parse route response: {e}") raise ValueError(f"Invalid route response: {e}") except Exception as e: logger.error(f"❌ Unexpected error in _compute_routes: {e}") raise # ======================================================================== # Multi-leg Route Computation # ======================================================================== @staticmethod def _encode_polyline(points: List[Tuple[float, float]]) -> str: def encode_coord(coord): coord = int(round(coord * 1e5)) coord <<= 1 if coord < 0: coord = ~coord result = "" while coord >= 0x20: result += chr((0x20 | (coord & 0x1f)) + 63) coord >>= 5 result += chr(coord + 63) return result encoded = "" last_lat, last_lng = 0, 0 for lat, lng in points: d_lat = lat - last_lat d_lng = lng - last_lng encoded += encode_coord(d_lat) + encode_coord(d_lng) last_lat, last_lng = lat, lng return encoded def compute_routes( self, place_points: List[Dict[str, float]], start_time: Union[datetime, str], stop_times: List[int], travel_mode: Union[str, List[str]] = "DRIVE", routing_preference: str = "TRAFFIC_AWARE_OPTIMAL" ) -> Dict[str, Any]: if len(place_points) < 2: raise ValueError("At least 2 places required for route computation") # ... (驗證 stop_times 長度與時間初始化代碼保持不變) ... # 處理開始時間 if start_time == "now" or start_time is None: start_time = datetime.now(timezone.utc) current_time = datetime.now(timezone.utc) elif isinstance(start_time, datetime): current_time = start_time.astimezone(timezone.utc) else: raise ValueError(f"Invalid start_time type: {type(start_time)}") legs_info = [] total_distance = 0 total_duration = 0 place_points = clean_dict_list_keys(place_points) num_legs = len(place_points) - 1 for i in range(num_legs): origin = place_points[i] destination = place_points[i + 1] # 1. 決定當前首選模式 if isinstance(travel_mode, list): primary_mode = travel_mode[i].upper() else: primary_mode = travel_mode.upper() modes_to_try = [] if primary_mode == "DRIVE": # 開車失敗 -> 試試機車 -> 再不行試試公車 (適合跨海/長途) -> 最後才走路 modes_to_try = ["DRIVE", "TWO_WHEELER", "TRANSIT", "WALK"] elif primary_mode == "TWO_WHEELER": modes_to_try = ["TWO_WHEELER", "TRANSIT", "WALK"] elif primary_mode == "TRANSIT": modes_to_try = ["TRANSIT", "WALK"] else: modes_to_try = ["WALK"] route_found = False final_mode_used = primary_mode leg_distance = 0 leg_duration = 0 encoded_polyline = "" # 3. 開始嘗試 for mode in modes_to_try: # 設定 Preference # ✅ TRANSIT 不支援 traffic_aware，必須設為 None if mode in ["DRIVE", "TWO_WHEELER"]: pref = None if routing_preference == "UNDRIVE" else routing_preference.upper() else: pref = None departure_time = current_time if i > 0 else None try: # 呼叫 API route = self._compute_routes( origin=origin, destination=destination, waypoints=None, travel_mode=mode, routing_preference=pref, include_traffic_on_polyline=True, # ✅ TRANSIT 模式非常依賴 departure_time，務必確保有傳入 departure_time=departure_time ) leg_distance = route["distance_meters"] leg_duration = route["duration_seconds"] encoded_polyline = route["encoded_polyline"] route_found = True final_mode_used = mode if mode != primary_mode: logger.info(f" 🔄 Leg {i + 1}: {primary_mode} failed. Switched to {mode} (Polyline OK).") break except Exception: continue # 4. 絕望情況：連走路都失敗 (Math Fallback) if not route_found: logger.warning(f"⚠️ Leg {i + 1}: All API modes (DRIVE/TWO_WHEELER/TRANSIT/WALK) failed.") logger.warning( f" 📍 From: {origin['lat']},{origin['lng']} -> To: {destination['lat']},{destination['lng']}") logger.warning(f" 🔄 Activating Math Fallback (Straight Line).") # 計算直線距離 leg_distance = self._calculate_haversine_distance( origin['lat'], origin['lng'], destination['lat'], destination['lng'] ) # 估算時間 (走路速度 5km/h) speed = 1.38 leg_duration = int(leg_distance / speed) # ✅ [FIX] 生成「直線 Polyline」給前端 # 雖然是直線，但至少前端不會因為空字串而報錯 encoded_polyline = self._encode_polyline([ (origin['lat'], origin['lng']), (destination['lat'], destination['lng']) ]) final_mode_used = "MATH_ESTIMATE" # --- 累加數據 --- total_distance += leg_distance total_duration += leg_duration legs_info.append({ "from_index": i, "to_index": i + 1, "travel_mode": final_mode_used, "distance_meters": leg_distance, "duration_seconds": leg_duration, "departure_time": current_time.isoformat(), "polyline": encoded_polyline # ✅ 現在這裡保證有值 }) # 更新時間 (使用秒數) current_time += timedelta(seconds=leg_duration) stop_duration = stop_times[i + 1] current_time += timedelta(seconds=stop_duration) return { "total_distance_meters": total_distance, "total_duration_seconds": total_duration, "total_residence_time_minutes": sum(stop_times) // 60, "total_time_seconds": int((current_time - start_time).total_seconds()), "start_time": start_time, "end_time": current_time, "stops": place_points, "legs": legs_info, } # ======================================================================== # Distance Matrix API # ======================================================================== def _compute_route_matrix( self, origins: List[Dict[str, float]], destinations: List[Dict[str, float]], travel_mode: str = "DRIVE", routing_preference: str = "TRAFFIC_UNAWARE", departure_time: Optional[datetime] = None ) -> Dict[str, Any]: """ Internal method to compute distance matrix Args: origins: List of origin location dicts destinations: List of destination location dicts travel_mode: Travel mode routing_preference: Routing preference departure_time: Departure time Returns: API response with distance matrix data Raises: requests.RequestException: If API request fails """ request_body = { "origins": [ { "waypoint": { "location": { "latLng": { "latitude": origin["lat"], "longitude": origin["lng"] } } } } for origin in origins ], "destinations": [ { "waypoint": { "location": { "latLng": { "latitude": dest["lat"], "longitude": dest["lng"] } } } } for dest in destinations ], "travelMode": travel_mode.upper(), "routingPreference": routing_preference.upper() } # ✅ 添加 departure_time if departure_time: if isinstance(departure_time, datetime): request_body["departureTime"] = departure_time.isoformat() elif departure_time == "now": request_body["departureTime"] = datetime.now(timezone.utc).isoformat() field_mask = "originIndex,destinationIndex,distanceMeters,duration" headers = { "Content-Type": "application/json", "X-Goog-Api-Key": self.api_key, "X-Goog-FieldMask": field_mask } logger.debug( f"📏 Computing route matrix: {len(origins)} × {len(destinations)}" ) try: response = requests.post( self.compute_route_matrix_url, json=request_body, headers=headers, timeout=30 ) response.raise_for_status() data = response.json() if "error" in data: raise ValueError(f"API Error: {data['error']}") if isinstance(data, list): return data elif "results" in data: return data["results"] else: # 兜底：返回空數組 logger.warning(f"⚠️ Unexpected Distance Matrix response format: {data.keys()}") return [] except requests.Timeout: logger.error("⏰ Route matrix request timeout") raise except requests.RequestException as e: logger.error(f"❌ Route matrix request failed: {e}") raise e except Exception as e: logger.error(f"❌ Unexpected error in _compute_route_matrix: {e}") raise def _get_max_elements(self, travel_mode: str, routing_preference: str) -> int: """ Get max elements per request based on travel mode and preference Args: travel_mode: Travel mode routing_preference: Routing preference Returns: Max elements allowed """ if travel_mode.upper() == "TRANSIT": return 100 if routing_preference and routing_preference.upper() == "TRAFFIC_AWARE_OPTIMAL": return 100 return 625 def compute_route_matrix( self, origins: List[Dict[str, float]], destinations: List[Dict[str, float]], travel_mode: str = "DRIVE", routing_preference: Optional[str] = None, departure_time: Optional[datetime] = None, ) -> Dict[str, np.ndarray]: """ ✅ P1-1 修復: 正確調用 _compute_route_matrix Compute distance and duration matrix between multiple locations Args: origins: List of origin location dicts with 'lat' and 'lng' destinations: List of destination location dicts with 'lat' and 'lng' travel_mode: Travel mode (DRIVE, WALK, BICYCLE, TRANSIT) routing_preference: Routing preference (optional) departure_time: Departure time as datetime object (optional) Returns: Dict with numpy arrays: - duration_matrix: Duration in seconds (shape: O×D) - distance_matrix: Distance in meters (shape: O×D) Raises: ValueError: If input is invalid requests.RequestException: If API request fails """ if not origins or not destinations: raise ValueError("Origins and destinations cannot be empty") max_elements = self._get_max_elements(travel_mode, routing_preference or "") O_len, D_len = len(origins), len(destinations) duration_matrix = np.full((O_len, D_len), -1, dtype=np.int32) distance_matrix = np.full((O_len, D_len), -1, dtype=np.int32) logger.info( f"📊 Computing {O_len}×{D_len} matrix " f"(max_elements={max_elements})" ) # ✅ 分批處理 for o_start in range(0, O_len, MAX_LOCATIONS_PER_SIDE): o_end = min(o_start + MAX_LOCATIONS_PER_SIDE, O_len) origin_batch = origins[o_start:o_end] origin_batch_size = len(origin_batch) max_dest_batch_size = max( 1, min( MAX_LOCATIONS_PER_SIDE, min(D_len, max_elements // origin_batch_size) ), ) for d_start in range(0, D_len, max_dest_batch_size): d_end = min(d_start + max_dest_batch_size, D_len) dest_batch = destinations[d_start:d_end] try: time.sleep(0.2) elements = self._compute_route_matrix( origins=origin_batch, destinations=dest_batch, travel_mode=travel_mode, routing_preference=routing_preference or "TRAFFIC_UNAWARE", departure_time=departure_time, ) if not elements: logger.warning( f"⚠️ No elements in batch " f"[{o_start}:{o_end}, {d_start}:{d_end}]" ) continue for el in elements: if "originIndex" not in el or "destinationIndex" not in el: continue oi = o_start + el["originIndex"] di = d_start + el["destinationIndex"] # ✅ 解析時間 (格式: "300s") duration_str = el.get("duration", "0s") duration_seconds = int(duration_str.rstrip("s")) # ✅ 解析距離 distance_meters = el.get("distanceMeters", 0) duration_matrix[oi, di] = duration_seconds distance_matrix[oi, di] = distance_meters except Exception as e: if "429" in str(e) or "Too Many Requests" in str(e): logger.error(f"🚨 Rate Limit Hit! Sleeping for 5s...") time.sleep(5) logger.error( f"❌ Failed to compute matrix batch " f"[{o_start}:{o_end}, {d_start}:{d_end}]: {e}") logger.info( f"✅ Route matrix computed: " f"{np.sum(duration_matrix >= 0)} / {O_len * D_len} elements" ) return { "duration_matrix": duration_matrix, "distance_matrix": distance_matrix, } # ============================================================================ # Usage Example # ============================================================================ if __name__ == "__main__": import os from src.infra.config import get_settings # Initialize service setting = get_settings() api_key = setting.google_maps_api_key if not api_key: print("❌ Please set GOOGLE_MAPS_API_KEY environment variable") exit(1) service = GoogleMapAPIService(api_key=api_key) # Example 1: Current location try: print("\n" + "="*60) print("Example 1: Current Location") print("="*60) location = service.current_location() print(f"📍 Current: {location['location']}") except Exception as e: print(f"❌ Failed: {e}") # Example 2: Text search try: print("\n" + "="*60) print("Example 2: Text Search") print("="*60) places = service.text_search( query="台大醫院", location={"lat": 25.0408, "lng": 121.5318}, radius=5000, limit=3 ) for i, place in enumerate(places, 1): print(f"{i}. {place['name']} - {place['address']}, {place['place_id']}") except Exception as e: print(f"❌ Failed: {e}") # Example 3: Compute route try: print("\n" + "="*60) print("Example 3: Compute Route") print("="*60) places = [ {"lat": 25.0408, "lng": 121.5318}, # 台北車站 {"lat": 25.0330, "lng": 121.5654}, # 台北101 {"lat": 25.0478, "lng": 121.5170}, # 西門町 ] route = service.compute_routes( place_points=places, start_time=datetime.now(timezone.utc), stop_times=[30, 60, 50], # 停留時間 (分鐘) travel_mode="DRIVE", routing_preference="TRAFFIC_AWARE" ##"TRAFFIC_AWARE_OPTIMAL" ) print(f"📊 Total distance: {route['total_distance_meters']}m") print(f"⏱️ Total duration: {route['total_duration_seconds']}s") print(f"🏁 End time: {route['end_time']}") except Exception as e: print(f"❌ Failed: {e}") raise e # Example 4: Distance matrix try: print("\n" + "="*60) print("Example 4: Distance Matrix") print("="*60) origins = [ {"lat": 25.0408, "lng": 121.5318}, {"lat": 25.0330, "lng": 121.5654}, ] destinations = [ {"lat": 25.0478, "lng": 121.5170}, {"lat": 25.0360, "lng": 121.5000}, ] matrices = service.compute_route_matrix( origins=origins, destinations=destinations, travel_mode="WALK" ) print("Duration matrix (seconds):") print(matrices["duration_matrix"]) print("\nDistance matrix (meters):") print(matrices["distance_matrix"]) except Exception as e: print(f"❌ Failed: {e}") print("\n✅ All examples completed!")