Update pygeos/mcp_output/mcp_plugin/mcp_service.py

pygeos/mcp_output/mcp_plugin/mcp_service.py

@@ -1,746 +1,44 @@
-import os
-import sys
-from typing import List, Optional
-
 from fastmcp import FastMCP
-import numpy as np
-import pygeos
 
 # Create the FastMCP service application
 mcp = FastMCP("pygeos_service")
 
-# ==================== Geometry Creation ====================
-
-@mcp.tool()
-def create_point(x: float, y: float, z: Optional[float] = None) -> dict:
-    """Create a point geometry from coordinates.
-    
-    Args:
-        x: X coordinate
-        y: Y coordinate
-        z: Optional Z coordinate for 3D point
-    
-    Returns:
-        dict: WKT representation of the created point
-    """
-    try:
-        if z is not None:
-            coords = [[x, y, z]]
-        else:
-            coords = [[x, y]]
-        point = pygeos.points(coords)[0]
-        wkt = pygeos.to_wkt(point)
-        return {"success": True, "wkt": wkt, "geometry_type": "Point"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def create_linestring(coordinates: List[List[float]]) -> dict:
-    """Create a linestring geometry from a list of coordinates.
-    
-    Args:
-        coordinates: List of [x, y] or [x, y, z] coordinate pairs, e.g. [[0, 0], [1, 1], [2, 0]]
-    
-    Returns:
-        dict: WKT representation of the created linestring
+@mcp.tool(name="list_geometries", description="List all available geometry types in PyGEOS")
+def list_geometries() -> dict:
     """
-    try:
-        coords = np.array(coordinates)
-        linestring = pygeos.linestrings([coords])[0]
-        wkt = pygeos.to_wkt(linestring)
-        return {"success": True, "wkt": wkt, "geometry_type": "LineString"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
+    List all available geometry types in PyGEOS.
 
-@mcp.tool()
-def create_polygon(shell: List[List[float]], holes: Optional[List[List[List[float]]]] = None) -> dict:
-    """Create a polygon geometry from shell and optional holes.
-    
-    Args:
-        shell: List of coordinates forming the exterior ring, e.g. [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]
-        holes: Optional list of hole rings
-    
     Returns:
-        dict: WKT representation of the created polygon
+    - dict: A dictionary with success status and list of geometry types.
     """
     try:
-        shell_ring = pygeos.linearrings([np.array(shell)])[0]
-        if holes:
-            hole_rings = [pygeos.linearrings([np.array(h)])[0] for h in holes]
-            polygon = pygeos.polygons(shell_ring, hole_rings)
-        else:
-            polygon = pygeos.polygons(shell_ring)
-        wkt = pygeos.to_wkt(polygon)
-        return {"success": True, "wkt": wkt, "geometry_type": "Polygon"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def create_box(xmin: float, ymin: float, xmax: float, ymax: float) -> dict:
-    """Create a rectangular polygon (box) from bounds.
-    
-    Args:
-        xmin: Minimum X coordinate
-        ymin: Minimum Y coordinate
-        xmax: Maximum X coordinate
-        ymax: Maximum Y coordinate
-    
-    Returns:
-        dict: WKT representation of the box polygon
-    """
-    try:
-        box = pygeos.box(xmin, ymin, xmax, ymax)
-        wkt = pygeos.to_wkt(box)
-        return {"success": True, "wkt": wkt, "geometry_type": "Polygon"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def from_wkt(wkt: str) -> dict:
-    """Parse a WKT string into a geometry and return its properties.
-    
-    Args:
-        wkt: Well-Known Text representation of geometry
-    
-    Returns:
-        dict: Geometry properties including type, validity, and bounds
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        geom_type = pygeos.get_type_id(geom)
-        type_names = {0: "Point", 1: "LineString", 2: "LinearRing", 3: "Polygon",
-                      4: "MultiPoint", 5: "MultiLineString", 6: "MultiPolygon", 7: "GeometryCollection"}
-        bounds = pygeos.bounds(geom).tolist()
+        from pygeos import GeometryType
+        geometries = [g.name for g in GeometryType]
         return {
             "success": True,
-            "wkt": pygeos.to_wkt(geom),
-            "geometry_type": type_names.get(int(geom_type), "Unknown"),
-            "is_valid": bool(pygeos.is_valid(geom)),
-            "is_empty": bool(pygeos.is_empty(geom)),
-            "bounds": {"xmin": bounds[0], "ymin": bounds[1], "xmax": bounds[2], "ymax": bounds[3]}
+            "geometries": geometries,
+            "count": len(geometries)
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-# ==================== Measurement ====================
-
-@mcp.tool()
-def calculate_distance(wkt1: str, wkt2: str) -> dict:
-    """Calculate the Cartesian distance between two geometries.
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: Distance between the geometries
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        distance = float(pygeos.distance(geom1, geom2))
-        return {"success": True, "distance": distance}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def calculate_area(wkt: str) -> dict:
-    """Calculate the area of a polygon geometry.
-    
-    Args:
-        wkt: WKT of the polygon geometry
-    
-    Returns:
-        dict: Area of the polygon
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        area = float(pygeos.area(geom))
-        return {"success": True, "area": area}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def calculate_length(wkt: str) -> dict:
-    """Calculate the length of a linear geometry.
-    
-    Args:
-        wkt: WKT of the linear geometry (LineString, MultiLineString, or polygon boundary)
-    
-    Returns:
-        dict: Length of the geometry
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        length = float(pygeos.length(geom))
-        return {"success": True, "length": length}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def get_bounds(wkt: str) -> dict:
-    """Get the bounding box of a geometry.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: Bounding box coordinates (xmin, ymin, xmax, ymax)
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        bounds = pygeos.bounds(geom).tolist()
-        return {
-            "success": True,
-            "xmin": bounds[0],
-            "ymin": bounds[1],
-            "xmax": bounds[2],
-            "ymax": bounds[3]
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def hausdorff_distance(wkt1: str, wkt2: str) -> dict:
-    """Calculate the Hausdorff distance between two geometries.
-    
-    The Hausdorff distance is a measure of the maximum distance between
-    the nearest points in two geometries.
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: Hausdorff distance
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        dist = float(pygeos.hausdorff_distance(geom1, geom2))
-        return {"success": True, "hausdorff_distance": dist}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-# ==================== Predicates ====================
-
-@mcp.tool()
-def check_intersects(wkt1: str, wkt2: str) -> dict:
-    """Check if two geometries intersect.
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: Boolean indicating intersection
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = bool(pygeos.intersects(geom1, geom2))
-        return {"success": True, "intersects": result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def check_contains(wkt1: str, wkt2: str) -> dict:
-    """Check if geometry 1 contains geometry 2.
-    
-    Args:
-        wkt1: WKT of the container geometry
-        wkt2: WKT of the contained geometry
-    
-    Returns:
-        dict: Boolean indicating containment
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = bool(pygeos.contains(geom1, geom2))
-        return {"success": True, "contains": result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def check_within(wkt1: str, wkt2: str) -> dict:
-    """Check if geometry 1 is within geometry 2.
-    
-    Args:
-        wkt1: WKT of the inner geometry
-        wkt2: WKT of the outer geometry
-    
-    Returns:
-        dict: Boolean indicating if geometry 1 is within geometry 2
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = bool(pygeos.within(geom1, geom2))
-        return {"success": True, "within": result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def check_touches(wkt1: str, wkt2: str) -> dict:
-    """Check if two geometries touch (share boundary but not interior).
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: Boolean indicating if geometries touch
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = bool(pygeos.touches(geom1, geom2))
-        return {"success": True, "touches": result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def check_crosses(wkt1: str, wkt2: str) -> dict:
-    """Check if two geometries cross each other.
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: Boolean indicating if geometries cross
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = bool(pygeos.crosses(geom1, geom2))
-        return {"success": True, "crosses": result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def check_overlaps(wkt1: str, wkt2: str) -> dict:
-    """Check if two geometries overlap.
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: Boolean indicating if geometries overlap
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = bool(pygeos.overlaps(geom1, geom2))
-        return {"success": True, "overlaps": result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def check_disjoint(wkt1: str, wkt2: str) -> dict:
-    """Check if two geometries are disjoint (do not interact).
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: Boolean indicating if geometries are disjoint
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = bool(pygeos.disjoint(geom1, geom2))
-        return {"success": True, "disjoint": result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def is_valid(wkt: str) -> dict:
-    """Check if a geometry is valid.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: Boolean indicating validity and reason if invalid
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        valid = bool(pygeos.is_valid(geom))
-        reason = pygeos.is_valid_reason(geom) if not valid else None
-        return {"success": True, "is_valid": valid, "reason": reason}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def is_simple(wkt: str) -> dict:
-    """Check if a geometry is simple (no self-intersection).
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: Boolean indicating if geometry is simple
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        result = bool(pygeos.is_simple(geom))
-        return {"success": True, "is_simple": result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-# ==================== Constructive Operations ====================
-
-@mcp.tool()
-def buffer_geometry(wkt: str, distance: float, quad_segs: int = 8) -> dict:
-    """Create a buffer around a geometry.
-    
-    Args:
-        wkt: WKT of the geometry
-        distance: Buffer distance (positive for expansion, negative for erosion)
-        quad_segs: Number of segments for quarter circle approximation
-    
-    Returns:
-        dict: WKT of the buffered geometry
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        buffered = pygeos.buffer(geom, distance, quadsegs=quad_segs)
-        wkt_result = pygeos.to_wkt(buffered)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def simplify_geometry(wkt: str, tolerance: float, preserve_topology: bool = True) -> dict:
-    """Simplify a geometry using Douglas-Peucker algorithm.
-    
-    Args:
-        wkt: WKT of the geometry
-        tolerance: Simplification tolerance
-        preserve_topology: Whether to preserve topology
-    
-    Returns:
-        dict: WKT of the simplified geometry
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        simplified = pygeos.simplify(geom, tolerance, preserve_topology=preserve_topology)
-        wkt_result = pygeos.to_wkt(simplified)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def get_centroid(wkt: str) -> dict:
-    """Get the centroid of a geometry.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: WKT of the centroid point
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        centroid = pygeos.centroid(geom)
-        wkt_result = pygeos.to_wkt(centroid)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def get_convex_hull(wkt: str) -> dict:
-    """Get the convex hull of a geometry.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: WKT of the convex hull
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        hull = pygeos.convex_hull(geom)
-        wkt_result = pygeos.to_wkt(hull)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def get_envelope(wkt: str) -> dict:
-    """Get the envelope (bounding box) of a geometry as a polygon.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: WKT of the envelope polygon
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        envelope = pygeos.envelope(geom)
-        wkt_result = pygeos.to_wkt(envelope)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def get_boundary(wkt: str) -> dict:
-    """Get the boundary of a geometry.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: WKT of the boundary
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        boundary = pygeos.boundary(geom)
-        wkt_result = pygeos.to_wkt(boundary)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def make_valid(wkt: str) -> dict:
-    """Make an invalid geometry valid.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: WKT of the valid geometry
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        valid_geom = pygeos.make_valid(geom)
-        wkt_result = pygeos.to_wkt(valid_geom)
-        return {"success": True, "wkt": wkt_result, "is_valid": bool(pygeos.is_valid(valid_geom))}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-# ==================== Set Operations ====================
-
-@mcp.tool()
-def geometry_intersection(wkt1: str, wkt2: str) -> dict:
-    """Compute the intersection of two geometries.
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: WKT of the intersection
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = pygeos.intersection(geom1, geom2)
-        wkt_result = pygeos.to_wkt(result)
-        return {"success": True, "wkt": wkt_result, "is_empty": bool(pygeos.is_empty(result))}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def geometry_union(wkt1: str, wkt2: str) -> dict:
-    """Compute the union of two geometries.
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: WKT of the union
+@mcp.tool(name="create_geometry", description="Create a geometry object in PyGEOS")
+def create_geometry(wkt: str) -> dict:
     """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = pygeos.union(geom1, geom2)
-        wkt_result = pygeos.to_wkt(result)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
+    Create a geometry object from a WKT string.
 
+    Parameters:
+    - wkt: Well-Known Text representation of the geometry
 
-@mcp.tool()
-def geometry_difference(wkt1: str, wkt2: str) -> dict:
-    """Compute the difference of two geometries (wkt1 - wkt2).
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the geometry to subtract
-    
     Returns:
-        dict: WKT of the difference
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = pygeos.difference(geom1, geom2)
-        wkt_result = pygeos.to_wkt(result)
-        return {"success": True, "wkt": wkt_result, "is_empty": bool(pygeos.is_empty(result))}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def geometry_symmetric_difference(wkt1: str, wkt2: str) -> dict:
-    """Compute the symmetric difference of two geometries.
-    
-    Args:
-        wkt1: WKT of the first geometry
-        wkt2: WKT of the second geometry
-    
-    Returns:
-        dict: WKT of the symmetric difference
-    """
-    try:
-        geom1 = pygeos.from_wkt(wkt1)
-        geom2 = pygeos.from_wkt(wkt2)
-        result = pygeos.symmetric_difference(geom1, geom2)
-        wkt_result = pygeos.to_wkt(result)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-# ==================== Linear Operations ====================
-
-@mcp.tool()
-def line_interpolate_point(wkt: str, distance: float, normalized: bool = False) -> dict:
-    """Interpolate a point along a line at a given distance.
-    
-    Args:
-        wkt: WKT of the line geometry
-        distance: Distance along the line (or fraction if normalized)
-        normalized: If True, distance is treated as fraction (0-1)
-    
-    Returns:
-        dict: WKT of the interpolated point
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        point = pygeos.line_interpolate_point(geom, distance, normalized=normalized)
-        wkt_result = pygeos.to_wkt(point)
-        return {"success": True, "wkt": wkt_result}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def line_locate_point(line_wkt: str, point_wkt: str, normalized: bool = False) -> dict:
-    """Find the distance along a line to the nearest point.
-    
-    Args:
-        line_wkt: WKT of the line geometry
-        point_wkt: WKT of the point
-        normalized: If True, return fraction (0-1) instead of distance
-    
-    Returns:
-        dict: Distance or fraction along the line
-    """
-    try:
-        line = pygeos.from_wkt(line_wkt)
-        point = pygeos.from_wkt(point_wkt)
-        distance = float(pygeos.line_locate_point(line, point, normalized=normalized))
-        return {"success": True, "distance": distance, "normalized": normalized}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-# ==================== Coordinate Operations ====================
-
-@mcp.tool()
-def get_coordinates(wkt: str) -> dict:
-    """Extract coordinates from a geometry.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: Array of coordinates
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        coords = pygeos.get_coordinates(geom).tolist()
-        return {"success": True, "coordinates": coords, "num_coordinates": len(coords)}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool()
-def get_num_coordinates(wkt: str) -> dict:
-    """Get the number of coordinates in a geometry.
-    
-    Args:
-        wkt: WKT of the geometry
-    
-    Returns:
-        dict: Number of coordinates
-    """
-    try:
-        geom = pygeos.from_wkt(wkt)
-        num = int(pygeos.get_num_coordinates(geom))
-        return {"success": True, "num_coordinates": num}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-# ==================== Utility ====================
-
-@mcp.tool()
-def get_pygeos_version() -> dict:
-    """Get the PyGEOS library version.
-    
-    Returns:
-        dict: Version information
+    - dict: Information about the created geometry
     """
     try:
+        from pygeos import from_wkt
+        geometry = from_wkt(wkt)
         return {
             "success": True,
-            "pygeos_version": pygeos.__version__,
-            "geos_version": pygeos.geos_version_string
+            "geometry": str(geometry)
         }
     except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-def create_app() -> FastMCP:
-    """Create and return the FastMCP application instance.
-    
-    Returns:
-        FastMCP: The application instance
-    """
-    return mcp
+        return {"success": False, "error": str(e)}