machinaos 0.0.1 → 0.0.6

package/server/services/maps.py

@@ -1,289 +1,289 @@
-"""Google Maps service for location operations."""
-
-import time
-import googlemaps
-from datetime import datetime
-from typing import Dict, Any
-
-from core.config import Settings
-from core.logging import get_logger, log_execution_time
-from services.auth import AuthService
-
-logger = get_logger(__name__)
-
-
-class MapsService:
-    """Google Maps and Places API service."""
-
-    def __init__(self, auth_service: AuthService, settings: Settings):
-        self.auth = auth_service
-        self.settings = settings
-
-    def validate_coordinates(self, lat: float, lng: float) -> bool:
-        """Validate latitude and longitude."""
-        return -90 <= lat <= 90 and -180 <= lng <= 180
-
-    def validate_zoom_level(self, zoom: int) -> bool:
-        """Validate Google Maps zoom level."""
-        return 0 <= zoom <= 21
-
-    async def create_map(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
-        """Create Google Maps configuration."""
-        start_time = time.time()
-
-        try:
-            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
-            if not api_key:
-                raise ValueError("Google Maps API key is required")
-
-            # Extract and validate parameters (snake_case)
-            lat = float(parameters.get('lat', 40.7128))
-            lng = float(parameters.get('lng', -74.0060))
-            zoom = int(parameters.get('zoom', 13))
-            map_type = parameters.get('map_type_id', 'ROADMAP')
-
-            if not self.validate_coordinates(lat, lng):
-                raise ValueError("Invalid coordinates")
-            if not self.validate_zoom_level(zoom):
-                raise ValueError("Invalid zoom level")
-            if map_type not in ['ROADMAP', 'SATELLITE', 'HYBRID', 'TERRAIN']:
-                raise ValueError("Invalid map type")
-
-            result = {
-                "map_config": {
-                    "center": {"lat": lat, "lng": lng},
-                    "zoom": zoom,
-                    "mapTypeId": map_type
-                },
-                "static_map_url": f"https://maps.googleapis.com/maps/api/staticmap?center={lat},{lng}&zoom={zoom}&size=600x400&maptype={map_type.lower()}&key={api_key}",
-                "status": "OK"
-            }
-
-            log_execution_time(logger, "create_map", start_time, time.time())
-
-            return {
-                "success": True,
-                "node_id": node_id,
-                "node_type": "createMap",
-                "operation": "map_initialization",
-                "result": result,
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-        except Exception as e:
-            logger.error("Create map failed", node_id=node_id, error=str(e))
-            return {
-                "success": False,
-                "node_id": node_id,
-                "node_type": "createMap",
-                "error": str(e),
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-    async def geocode_location(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
-        """Geocode addresses or reverse geocode coordinates."""
-        start_time = time.time()
-
-        try:
-            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
-            if not api_key:
-                raise ValueError("Google Maps API key is required")
-
-            gmaps = googlemaps.Client(key=api_key)
-            service_type = parameters.get('service_type', 'geocode')
-
-            if service_type == 'geocode':
-                address = parameters.get('address', '')
-                if not address:
-                    raise ValueError("Address is required for geocoding")
-
-                geocode_result = gmaps.geocode(address=address)
-                result = {
-                    "service_type": "geocoding",
-                    "input": {"address": address},
-                    "results": geocode_result,
-                    "status": "OK" if geocode_result else "ZERO_RESULTS"
-                }
-
-            elif service_type == 'reverse_geocode':
-                lat = float(parameters.get('lat', 0))
-                lng = float(parameters.get('lng', 0))
-
-                if not self.validate_coordinates(lat, lng):
-                    raise ValueError("Invalid coordinates")
-
-                reverse_result = gmaps.reverse_geocode((lat, lng))
-                result = {
-                    "service_type": "reverse_geocoding",
-                    "input": {"lat": lat, "lng": lng},
-                    "results": reverse_result,
-                    "status": "OK" if reverse_result else "ZERO_RESULTS"
-                }
-
-            else:
-                raise ValueError(f"Unsupported service type: {service_type}")
-
-            log_execution_time(logger, f"geocoding_{service_type}", start_time, time.time())
-
-            return {
-                "success": True,
-                "node_id": node_id,
-                "node_type": "addLocations",
-                "operation": service_type,
-                "result": result,
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-        except googlemaps.exceptions.ApiError as e:
-            logger.error("Google Maps API error", node_id=node_id, error=str(e))
-            return {
-                "success": False,
-                "node_id": node_id,
-                "node_type": "addLocations",
-                "error": f"Google Maps API error: {str(e)}",
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-        except Exception as e:
-            logger.error("Geocoding failed", node_id=node_id, error=str(e))
-            return {
-                "success": False,
-                "node_id": node_id,
-                "node_type": "addLocations",
-                "error": str(e),
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-    async def find_nearby_places(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
-        """Find nearby places using Google Places API."""
-        start_time = time.time()
-
-        try:
-            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
-            if not api_key:
-                raise ValueError("Google Maps API key is required")
-
-            gmaps = googlemaps.Client(key=api_key)
-
-            # Extract and validate parameters
-            lat = float(parameters.get('lat', 40.7484))
-            lng = float(parameters.get('lng', -73.9857))
-            radius = int(parameters.get('radius', 500))
-
-            if not self.validate_coordinates(lat, lng):
-                raise ValueError("Invalid coordinates")
-            if not (1 <= radius <= 50000):
-                raise ValueError("Radius must be between 1 and 50000 meters")
-
-            # Optional parameters (snake_case)
-            place_type = parameters.get('type', 'restaurant')
-            page_size = min(int(parameters.get('page_size', 20)), 20)
-
-            # Extract options (may contain keyword, name, min_price, max_price, open_now, language, rank_by)
-            options = parameters.get('options', {})
-
-            # Support both nested options and top-level parameters (snake_case)
-            keyword = options.get('keyword', '') if isinstance(options, dict) else parameters.get('keyword', '')
-            name_filter = options.get('name', '') if isinstance(options, dict) else parameters.get('name', '')
-            min_price = options.get('min_price') if isinstance(options, dict) else parameters.get('min_price')
-            max_price = options.get('max_price') if isinstance(options, dict) else parameters.get('max_price')
-            open_now = options.get('open_now', False) if isinstance(options, dict) else parameters.get('open_now', False)
-            language = options.get('language', 'en') if isinstance(options, dict) else parameters.get('language', 'en')
-            rank_by = options.get('rank_by', 'prominence') if isinstance(options, dict) else parameters.get('rank_by', 'prominence')
-
-            logger.debug("[Nearby Places] Extracted parameters",
-                        keyword=keyword,
-                        name_filter=name_filter,
-                        min_price=min_price,
-                        max_price=max_price,
-                        open_now=open_now,
-                        language=language,
-                        rank_by=rank_by,
-                        place_type=place_type)
-
-            # Build search request
-            search_params = {
-                'location': (lat, lng),
-                'type': place_type
-            }
-
-            # Add radius unless ranking by distance
-            if rank_by != 'distance':
-                search_params['radius'] = radius
-            else:
-                search_params['rank_by'] = rank_by
-
-            # Add optional parameters
-            if keyword:
-                search_params['keyword'] = keyword
-            if name_filter:
-                search_params['name'] = name_filter
-            if min_price is not None and min_price != '':
-                search_params['min_price'] = int(min_price)
-            if max_price is not None and max_price != '':
-                search_params['max_price'] = int(max_price)
-            if open_now:
-                search_params['open_now'] = True
-            if language:
-                search_params['language'] = language
-
-            nearby_result = gmaps.places_nearby(**search_params)
-            results = nearby_result.get('results', [])[:page_size]
-
-            result = {
-                "search_parameters": {
-                    "location": {"lat": lat, "lng": lng},
-                    "radius": radius if rank_by != 'distance' else None,
-                    "type": place_type,
-                    "keyword": keyword or None,
-                    "name_filter": name_filter or None,
-                    "min_price": min_price if min_price not in [None, ''] else None,
-                    "max_price": max_price if max_price not in [None, ''] else None,
-                    "open_now": open_now,
-                    "language": language,
-                    "rank_by": rank_by,
-                    "page_size": page_size
-                },
-                "results": results,
-                "total_results": len(results),
-                "status": nearby_result.get('status', 'OK')
-            }
-
-            log_execution_time(logger, "nearby_places", start_time, time.time())
-
-            return {
-                "success": True,
-                "node_id": node_id,
-                "node_type": "showNearbyPlaces",
-                "operation": "nearby_search",
-                "result": result,
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-        except googlemaps.exceptions.ApiError as e:
-            logger.error("Google Places API error", node_id=node_id, error=str(e))
-            return {
-                "success": False,
-                "node_id": node_id,
-                "node_type": "showNearbyPlaces",
-                "error": f"Google Places API error: {str(e)}",
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
-            }
-
-        except Exception as e:
-            logger.error("Nearby places search failed", node_id=node_id, error=str(e))
-            return {
-                "success": False,
-                "node_id": node_id,
-                "node_type": "showNearbyPlaces",
-                "error": str(e),
-                "execution_time": time.time() - start_time,
-                "timestamp": datetime.now().isoformat()
+"""Google Maps service for location operations."""
+
+import time
+import googlemaps
+from datetime import datetime
+from typing import Dict, Any
+
+from core.config import Settings
+from core.logging import get_logger, log_execution_time
+from services.auth import AuthService
+
+logger = get_logger(__name__)
+
+
+class MapsService:
+    """Google Maps and Places API service."""
+
+    def __init__(self, auth_service: AuthService, settings: Settings):
+        self.auth = auth_service
+        self.settings = settings
+
+    def validate_coordinates(self, lat: float, lng: float) -> bool:
+        """Validate latitude and longitude."""
+        return -90 <= lat <= 90 and -180 <= lng <= 180
+
+    def validate_zoom_level(self, zoom: int) -> bool:
+        """Validate Google Maps zoom level."""
+        return 0 <= zoom <= 21
+
+    async def create_map(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Create Google Maps configuration."""
+        start_time = time.time()
+
+        try:
+            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            if not api_key:
+                raise ValueError("Google Maps API key is required")
+
+            # Extract and validate parameters (snake_case)
+            lat = float(parameters.get('lat', 40.7128))
+            lng = float(parameters.get('lng', -74.0060))
+            zoom = int(parameters.get('zoom', 13))
+            map_type = parameters.get('map_type_id', 'ROADMAP')
+
+            if not self.validate_coordinates(lat, lng):
+                raise ValueError("Invalid coordinates")
+            if not self.validate_zoom_level(zoom):
+                raise ValueError("Invalid zoom level")
+            if map_type not in ['ROADMAP', 'SATELLITE', 'HYBRID', 'TERRAIN']:
+                raise ValueError("Invalid map type")
+
+            result = {
+                "map_config": {
+                    "center": {"lat": lat, "lng": lng},
+                    "zoom": zoom,
+                    "mapTypeId": map_type
+                },
+                "static_map_url": f"https://maps.googleapis.com/maps/api/staticmap?center={lat},{lng}&zoom={zoom}&size=600x400&maptype={map_type.lower()}&key={api_key}",
+                "status": "OK"
+            }
+
+            log_execution_time(logger, "create_map", start_time, time.time())
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "createMap",
+                "operation": "map_initialization",
+                "result": result,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            logger.error("Create map failed", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "createMap",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    async def geocode_location(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Geocode addresses or reverse geocode coordinates."""
+        start_time = time.time()
+
+        try:
+            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            if not api_key:
+                raise ValueError("Google Maps API key is required")
+
+            gmaps = googlemaps.Client(key=api_key)
+            service_type = parameters.get('service_type', 'geocode')
+
+            if service_type == 'geocode':
+                address = parameters.get('address', '')
+                if not address:
+                    raise ValueError("Address is required for geocoding")
+
+                geocode_result = gmaps.geocode(address=address)
+                result = {
+                    "service_type": "geocoding",
+                    "input": {"address": address},
+                    "results": geocode_result,
+                    "status": "OK" if geocode_result else "ZERO_RESULTS"
+                }
+
+            elif service_type == 'reverse_geocode':
+                lat = float(parameters.get('lat', 0))
+                lng = float(parameters.get('lng', 0))
+
+                if not self.validate_coordinates(lat, lng):
+                    raise ValueError("Invalid coordinates")
+
+                reverse_result = gmaps.reverse_geocode((lat, lng))
+                result = {
+                    "service_type": "reverse_geocoding",
+                    "input": {"lat": lat, "lng": lng},
+                    "results": reverse_result,
+                    "status": "OK" if reverse_result else "ZERO_RESULTS"
+                }
+
+            else:
+                raise ValueError(f"Unsupported service type: {service_type}")
+
+            log_execution_time(logger, f"geocoding_{service_type}", start_time, time.time())
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "addLocations",
+                "operation": service_type,
+                "result": result,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except googlemaps.exceptions.ApiError as e:
+            logger.error("Google Maps API error", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "addLocations",
+                "error": f"Google Maps API error: {str(e)}",
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            logger.error("Geocoding failed", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "addLocations",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+    async def find_nearby_places(self, node_id: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Find nearby places using Google Places API."""
+        start_time = time.time()
+
+        try:
+            api_key = parameters.get('api_key') or self.settings.google_maps_api_key
+            if not api_key:
+                raise ValueError("Google Maps API key is required")
+
+            gmaps = googlemaps.Client(key=api_key)
+
+            # Extract and validate parameters
+            lat = float(parameters.get('lat', 40.7484))
+            lng = float(parameters.get('lng', -73.9857))
+            radius = int(parameters.get('radius', 500))
+
+            if not self.validate_coordinates(lat, lng):
+                raise ValueError("Invalid coordinates")
+            if not (1 <= radius <= 50000):
+                raise ValueError("Radius must be between 1 and 50000 meters")
+
+            # Optional parameters (snake_case)
+            place_type = parameters.get('type', 'restaurant')
+            page_size = min(int(parameters.get('page_size', 20)), 20)
+
+            # Extract options (may contain keyword, name, min_price, max_price, open_now, language, rank_by)
+            options = parameters.get('options', {})
+
+            # Support both nested options and top-level parameters (snake_case)
+            keyword = options.get('keyword', '') if isinstance(options, dict) else parameters.get('keyword', '')
+            name_filter = options.get('name', '') if isinstance(options, dict) else parameters.get('name', '')
+            min_price = options.get('min_price') if isinstance(options, dict) else parameters.get('min_price')
+            max_price = options.get('max_price') if isinstance(options, dict) else parameters.get('max_price')
+            open_now = options.get('open_now', False) if isinstance(options, dict) else parameters.get('open_now', False)
+            language = options.get('language', 'en') if isinstance(options, dict) else parameters.get('language', 'en')
+            rank_by = options.get('rank_by', 'prominence') if isinstance(options, dict) else parameters.get('rank_by', 'prominence')
+
+            logger.debug("[Nearby Places] Extracted parameters",
+                        keyword=keyword,
+                        name_filter=name_filter,
+                        min_price=min_price,
+                        max_price=max_price,
+                        open_now=open_now,
+                        language=language,
+                        rank_by=rank_by,
+                        place_type=place_type)
+
+            # Build search request
+            search_params = {
+                'location': (lat, lng),
+                'type': place_type
+            }
+
+            # Add radius unless ranking by distance
+            if rank_by != 'distance':
+                search_params['radius'] = radius
+            else:
+                search_params['rank_by'] = rank_by
+
+            # Add optional parameters
+            if keyword:
+                search_params['keyword'] = keyword
+            if name_filter:
+                search_params['name'] = name_filter
+            if min_price is not None and min_price != '':
+                search_params['min_price'] = int(min_price)
+            if max_price is not None and max_price != '':
+                search_params['max_price'] = int(max_price)
+            if open_now:
+                search_params['open_now'] = True
+            if language:
+                search_params['language'] = language
+
+            nearby_result = gmaps.places_nearby(**search_params)
+            results = nearby_result.get('results', [])[:page_size]
+
+            result = {
+                "search_parameters": {
+                    "location": {"lat": lat, "lng": lng},
+                    "radius": radius if rank_by != 'distance' else None,
+                    "type": place_type,
+                    "keyword": keyword or None,
+                    "name_filter": name_filter or None,
+                    "min_price": min_price if min_price not in [None, ''] else None,
+                    "max_price": max_price if max_price not in [None, ''] else None,
+                    "open_now": open_now,
+                    "language": language,
+                    "rank_by": rank_by,
+                    "page_size": page_size
+                },
+                "results": results,
+                "total_results": len(results),
+                "status": nearby_result.get('status', 'OK')
+            }
+
+            log_execution_time(logger, "nearby_places", start_time, time.time())
+
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "showNearbyPlaces",
+                "operation": "nearby_search",
+                "result": result,
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except googlemaps.exceptions.ApiError as e:
+            logger.error("Google Places API error", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "showNearbyPlaces",
+                "error": f"Google Places API error: {str(e)}",
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            logger.error("Nearby places search failed", node_id=node_id, error=str(e))
+            return {
+                "success": False,
+                "node_id": node_id,
+                "node_type": "showNearbyPlaces",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
             }