Using names instead of geoloc

app.py

@@ -1,161 +1,110 @@
 import gradio as gr
 from camptocamp_api import CamptocampAPI
-from typing import Tuple, Optional
+from typing import Optional
 
-
-# Instantiate the Camptocamp API wrapper
 c2c = CamptocampAPI(language="en")
 
-
-def get_recent_outings(
-    west: float,
-    south: float,
-    east: float,
-    north: float,
+def get_recent_outings_by_location(
+    location: str,
     start_date: Optional[str] = None,
     end_date: Optional[str] = None,
     activity: Optional[str] = None,
     limit: int = 10
 ) -> dict:
     """
-    Get recent outings near a given location and date range.
-
-    Args:
-        west: Western longitude of the bounding box.
-        south: Southern latitude of the bounding box.
-        east: Eastern longitude of the bounding box.
-        north: Northern latitude of the bounding box.
-        start_date: Start of the date range (YYYY-MM-DD).
-        end_date: End of the date range (YYYY-MM-DD).
-        activity: Optional activity filter (e.g. "hiking", "rock_climbing").
-        limit: Number of results to return.
-
-    Returns:
-        JSON dictionary of matching outings.
+    Get recent outings for a location name using geocoded bounding box.
     """
-    bbox = (west, south, east, north)
+    bbox = c2c.get_bbox_from_location(location)
+    if not bbox:
+        return {"error": f"Could not resolve bounding box for location: {location}"}
     date_range = (start_date, end_date) if start_date and end_date else None
     return c2c.get_recent_outings(bbox, date_range, activity, limit)
 
-
-def search_routes_by_activity(
-    west: float,
-    south: float,
-    east: float,
-    north: float,
+def search_routes_by_location(
+    location: str,
     activity: str,
     limit: int = 10
 ) -> dict:
     """
-    Search for climbing or hiking routes in a given region.
-
-    Args:
-        west: Western longitude of the bounding box.
-        south: Southern latitude of the bounding box.
-        east: Eastern longitude of the bounding box.
-        north: Northern latitude of the bounding box.
-        activity: Activity type (e.g. "rock_climbing", "hiking").
-        limit: Number of routes to return.
-
-    Returns:
-        JSON dictionary of matching route metadata.
+    Search for routes near a named location.
     """
-    bbox = (west, south, east, north)
+    bbox = c2c.get_bbox_from_location(location)
+    if not bbox:
+        return {"error": f"Could not find bounding box for location: {location}"}
     return c2c.search_routes_by_activity(bbox, activity, limit)
 
-
 def get_route_details(route_id: int) -> dict:
     """
     Retrieve detailed route information by route ID.
-
-    Args:
-        route_id: Unique numeric ID of the route.
-
-    Returns:
-        JSON dictionary of route information including description, grade, etc.
     """
     return c2c.get_route_details(route_id)
 
-
-def search_waypoints(
-    west: float,
-    south: float,
-    east: float,
-    north: float,
-    limit: int = 10
-) -> dict:
+def search_waypoints_by_location(location: str, limit: int = 10) -> dict:
     """
-    Get known waypoints (e.g. huts, peaks, cols) in a given area.
-
-    Args:
-        west: Western longitude of the bounding box.
-        south: Southern latitude of the bounding box.
-        east: Eastern longitude of the bounding box.
-        north: Northern latitude of the bounding box.
-        limit: Maximum number of results.
-
-    Returns:
-        JSON dictionary of waypoints.
+    Get known waypoints (e.g. huts, peaks) in a given region.
     """
-    bbox = (west, south, east, north)
+    bbox = c2c.get_bbox_from_location(location)
+    if not bbox:
+        return {"error": f"No bounding box found for: {location}"}
     return c2c.search_waypoints(bbox, limit)
 
-
-# ========== Gradio UI Layer ==========
-
-with gr.Blocks(title="Camptocamp API MCP") as demo:
-    gr.Markdown("# 🏔️ Camptocamp API Interface")
-
-    with gr.Tab("Recent Outings"):
-        with gr.Row():
-            west = gr.Number(label="West")
-            south = gr.Number(label="South")
-            east = gr.Number(label="East")
-            north = gr.Number(label="North")
-        with gr.Row():
-            start_date = gr.Textbox(label="Start Date (YYYY-MM-DD)")
-            end_date = gr.Textbox(label="End Date (YYYY-MM-DD)")
-            activity = gr.Textbox(label="Activity (e.g. hiking, skiing)")
-            limit = gr.Number(label="Limit", value=5)
-        outings_output = gr.JSON()
-        outings_btn = gr.Button("Get Outings")
-        outings_btn.click(get_recent_outings,
-                          inputs=[west, south, east, north, start_date, end_date, activity, limit],
-                          outputs=outings_output)
-
-    with gr.Tab("Routes"):
-        with gr.Row():
-            r_west = gr.Number(label="West")
-            r_south = gr.Number(label="South")
-            r_east = gr.Number(label="East")
-            r_north = gr.Number(label="North")
-        r_activity = gr.Textbox(label="Activity")
-        r_limit = gr.Number(label="Limit", value=5)
-        route_output = gr.JSON()
-        route_btn = gr.Button("Search Routes")
-        route_btn.click(search_routes_by_activity,
-                        inputs=[r_west, r_south, r_east, r_north, r_activity, r_limit],
-                        outputs=route_output)
-
-    with gr.Tab("Route Details"):
-        route_id_input = gr.Number(label="Route ID")
-        route_details_output = gr.JSON()
-        route_details_btn = gr.Button("Get Route Details")
-        route_details_btn.click(get_route_details,
-                                inputs=[route_id_input],
-                                outputs=route_details_output)
-
-    with gr.Tab("Waypoints"):
-        with gr.Row():
-            w_west = gr.Number(label="West")
-            w_south = gr.Number(label="South")
-            w_east = gr.Number(label="East")
-            w_north = gr.Number(label="North")
-        w_limit = gr.Number(label="Limit", value=5)
-        waypoints_output = gr.JSON()
-        waypoints_btn = gr.Button("Search Waypoints")
-        waypoints_btn.click(search_waypoints,
-                            inputs=[w_west, w_south, w_east, w_north, w_limit],
-                            outputs=waypoints_output)
+def lookup_bbox_from_location(location_name: str) -> Optional[dict]:
+    """
+    Look up the bounding box for a given place name.
+    """
+    bbox = c2c.get_bbox_from_location(location_name)
+    if not bbox:
+        return {"error": f"No bounding box found for: {location_name}"}
+    return {
+        "west": bbox[0],
+        "south": bbox[1],
+        "east": bbox[2],
+        "north": bbox[3]
+    }
+
+with gr.Blocks(title="Camptocamp MCP Server") as demo:
+    gr.Markdown("# 🏔️ Camptocamp API via MCP")
+
+    with gr.Tab("📍 Recent Outings"):
+        loc = gr.Textbox(label="Location (e.g. Chamonix, La Grave)")
+        start = gr.Textbox(label="Start Date (YYYY-MM-DD)")
+        end = gr.Textbox(label="End Date (YYYY-MM-DD)")
+        act = gr.Textbox(label="Activity (e.g. hiking, climbing)")
+        limit = gr.Number(label="Result Limit", value=5)
+        out = gr.JSON()
+        gr.Button("Get Outings").click(get_recent_outings_by_location,
+                                       inputs=[loc, start, end, act, limit],
+                                       outputs=out)
+
+    with gr.Tab("🧗 Search Routes"):
+        rloc = gr.Textbox(label="Location (e.g. Alps)")
+        ract = gr.Textbox(label="Activity (e.g. rock_climbing)")
+        rlim = gr.Number(label="Result Limit", value=5)
+        rout = gr.JSON()
+        gr.Button("Search Routes").click(search_routes_by_location,
+                                         inputs=[rloc, ract, rlim],
+                                         outputs=rout)
+
+    with gr.Tab("📄 Route Details"):
+        rid = gr.Number(label="Route ID")
+        rdet = gr.JSON()
+        gr.Button("Get Route Details").click(get_route_details,
+                                             inputs=[rid],
+                                             outputs=rdet)
+
+    with gr.Tab("⛰ Waypoints"):
+        wloc = gr.Textbox(label="Location (e.g. Mont Blanc)")
+        wlim = gr.Number(label="Result Limit", value=5)
+        wout = gr.JSON()
+        gr.Button("Get Waypoints").click(search_waypoints_by_location,
+                                         inputs=[wloc, wlim],
+                                         outputs=wout)
+
+    with gr.Tab("🌍 Location → BBox"):
+        lstr = gr.Textbox(label="Location Name")
+        lout = gr.JSON()
+        gr.Button("Lookup BBox").click(lookup_bbox_from_location,
+                                       inputs=[lstr],
+                                       outputs=lout)
 
 demo.launch()

camptocamp_api.py

@@ -11,28 +11,11 @@ class CamptocampAPI:
     BASE_URL = "https://api.camptocamp.org"
 
     def __init__(self, language: str = "en") -> None:
-        """
-        Initialize the API client.
-
-        Args:
-            language (str): Language code for results ('en', 'fr', etc.).
-        """
         self.language = language
 
     def _request(self, endpoint: str, params: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Internal method to send a GET request to the Camptocamp API.
-
-        Args:
-            endpoint (str): API endpoint (e.g., "/outings").
-            params (Dict): Dictionary of query parameters.
-
-        Returns:
-            Dict: Parsed JSON response.
-        """
         params["pl"] = self.language
-        url = f"{self.BASE_URL}{endpoint}"
-        response = requests.get(url, params=params)
+        response = requests.get(f"{self.BASE_URL}{endpoint}", params=params)
         response.raise_for_status()
         return response.json()
 
@@ -41,86 +24,74 @@ class CamptocampAPI:
         bbox: Tuple[float, float, float, float],
         date_range: Optional[Tuple[str, str]] = None,
         activity: Optional[str] = None,
-        limit: int = 10,
+        limit: int = 10
     ) -> Dict[str, Any]:
-        """
-        Get recent outings around a specific location and date.
-
-        Args:
-            bbox (Tuple[float, float, float, float]): Bounding box as (west, south, east, north).
-            date_range (Optional[Tuple[str, str]]): Date range (start, end) in YYYY-MM-DD format.
-            activity (Optional[str]): Activity filter (e.g., "climbing", "hiking").
-            limit (int): Max number of results.
-
-        Returns:
-            Dict: API response containing outings.
-        """
         params = {
             "bbox": ",".join(map(str, bbox)),
             "limit": limit,
-            "orderby": "-date",
+            "orderby": "-date"
         }
         if date_range:
             params["date"] = f"{date_range[0]},{date_range[1]}"
         if activity:
             params["act"] = activity
-
         return self._request("/outings", params)
 
     def search_routes_by_activity(
         self,
         bbox: Tuple[float, float, float, float],
         activity: str,
-        limit: int = 10,
+        limit: int = 10
     ) -> Dict[str, Any]:
-        """
-        Search for routes in a given area and activity type.
-
-        Args:
-            bbox (Tuple[float, float, float, float]): Bounding box as (west, south, east, north).
-            activity (str): Activity filter (e.g., "rock_climbing").
-            limit (int): Max number of results.
-
-        Returns:
-            Dict: API response containing route data.
-        """
         params = {
             "bbox": ",".join(map(str, bbox)),
             "act": activity,
             "limit": limit,
-            "orderby": "-date",
+            "orderby": "-date"
         }
         return self._request("/routes", params)
 
     def get_route_details(self, route_id: int) -> Dict[str, Any]:
-        """
-        Retrieve full route information by its ID.
-
-        Args:
-            route_id (int): Camptocamp route ID.
-
-        Returns:
-            Dict: Full route document with metadata and description.
-        """
         return self._request(f"/routes/{route_id}/{self.language}", {})
 
     def search_waypoints(
         self,
         bbox: Tuple[float, float, float, float],
-        limit: int = 10,
+        limit: int = 10
     ) -> Dict[str, Any]:
+        params = {
+            "bbox": ",".join(map(str, bbox)),
+            "limit": limit
+        }
+        return self._request("/waypoints", params)
+
+    @staticmethod
+    def get_bbox_from_location(query: str) -> Optional[Tuple[float, float, float, float]]:
         """
-        Get waypoints (e.g., huts, summits) within a given area.
+        Geocode a location string and return a bounding box.
 
         Args:
-            bbox (Tuple[float, float, float, float]): Bounding box as (west, south, east, north).
-            limit (int): Max number of results.
+            query: Name of the place or location (e.g., "Chamonix, France").
 
         Returns:
-            Dict: API response with waypoint data.
+            Bounding box as (west, south, east, north) or None if not found.
         """
+        url = "https://nominatim.openstreetmap.org/search"
         params = {
-            "bbox": ",".join(map(str, bbox)),
-            "limit": limit,
+            "q": query,
+            "format": "json",
+            "limit": 1
         }
-        return self._request("/waypoints", params)
+        headers = {"User-Agent": "camptocamp-api-wrapper"}
+        response = requests.get(url, params=params, headers=headers)
+        response.raise_for_status()
+        results = response.json()
+        if not results:
+            return None
+        bbox = results[0]["boundingbox"]  # ['south', 'north', 'west', 'east']
+        return (
+            float(bbox[2]),  # west
+            float(bbox[0]),  # south
+            float(bbox[3]),  # east
+            float(bbox[1])   # north
+        )