add API

app.py

@@ -3,8 +3,8 @@ import geopandas as gpd
 import requests
 import io
 import re
-from fastapi import FastAPI
-import kml2geojson
+from fastapi import FastAPI, HTTPException
+from urllib.parse import unquote
 
 # All helper functions from the previous version remain the same.
 
@@ -12,12 +12,6 @@ def get_gdf_from_file_url(file_url: str):
     """
     Downloads a file from a URL (handling Google Drive links), determines if it's
     KML or GeoJSON, and reads it into a GeoDataFrame.
-    
-    Args:
-        file_url: The URL of the KML or GeoJSON file.
-
-    Returns:
-        A GeoDataFrame containing the data from the file.
     """
     if "drive.google.com" in file_url:
         match = re.search(r'/d/([a-zA-Z0-9_-]+)', file_url) or re.search(r'id=([a-zA-Z0-9_-]+)', file_url)
@@ -54,57 +48,90 @@ def get_gdf_from_file_url(file_url: str):
     return input_gdf
 
 
-def calculate_geometry(file_url: str) -> tuple[str, str]:
+def calculate_geometry_data(file_url: str) -> dict:
     """
-    Main calculation logic.
+    Performs the core calculation and returns structured data (a dictionary).
+    This is used by both the API and the Gradio UI.
     """
     if not file_url or not file_url.strip():
-        return "Error: No URL provided.", ""
+        raise ValueError("No URL provided.")
 
-    try:
-        input_gdf = get_gdf_from_file_url(file_url)
-        if input_gdf.empty:
-            return "Error: Could not find any geometric features in the file.", ""
-        
-        geometry_gdf = None
-        for i, row in input_gdf.iterrows():
-            if row.geometry.geom_type in ['Polygon', 'MultiPolygon']:
-                geometry_gdf = gpd.GeoDataFrame([row], crs=input_gdf.crs)
-                break
-        
-        if geometry_gdf is None:
-            return "Error: No valid Polygon or MultiPolygon geometry found in the file.", ""
-
-        if geometry_gdf.crs is None or geometry_gdf.crs.to_epsg() != 4326:
-             geometry_gdf = geometry_gdf.set_crs(epsg=4326, allow_override=True)
-
-        centroid = geometry_gdf.geometry.iloc[0].centroid
-        utm_zone = int((centroid.x + 180) / 6) + 1
-        epsg_code = 32600 + utm_zone if centroid.y >= 0 else 32700 + utm_zone
-        gdf_proj = geometry_gdf.to_crs(epsg=epsg_code)
-
-        area_m2 = gdf_proj.geometry.iloc[0].area
-        perimeter_m = gdf_proj.geometry.iloc[0].length
-
-        area_km2 = area_m2 / 1_000_000
-        perimeter_km = perimeter_m / 1_000
-
-        area_str = f"{area_m2:,.2f} square meters ({area_km2:,.2f} km²)"
-        perimeter_str = f"{perimeter_m:,.2f} meters ({perimeter_km:,.2f} km)"
+    input_gdf = get_gdf_from_file_url(file_url)
+    if input_gdf.empty:
+        raise ValueError("Could not find any geometric features in the file.")
+    
+    geometry_gdf = None
+    for i, row in input_gdf.iterrows():
+        if row.geometry.geom_type in ['Polygon', 'MultiPolygon']:
+            geometry_gdf = gpd.GeoDataFrame([row], crs=input_gdf.crs)
+            break
+    
+    if geometry_gdf is None:
+        raise ValueError("No valid Polygon or MultiPolygon geometry found in the file.")
+
+    if geometry_gdf.crs is None or geometry_gdf.crs.to_epsg() != 4326:
+            geometry_gdf = geometry_gdf.set_crs(epsg=4326, allow_override=True)
 
+    centroid = geometry_gdf.geometry.iloc[0].centroid
+    utm_zone = int((centroid.x + 180) / 6) + 1
+    epsg_code = 32600 + utm_zone if centroid.y >= 0 else 32700 + utm_zone
+    gdf_proj = geometry_gdf.to_crs(epsg=epsg_code)
+
+    area_m2 = gdf_proj.geometry.iloc[0].area
+    perimeter_m = gdf_proj.geometry.iloc[0].length
+
+    return {
+        "area": {"value": area_m2, "unit": "square_meters"},
+        "perimeter": {"value": perimeter_m, "unit": "meters"},
+        "area_km2": {"value": area_m2 / 1_000_000, "unit": "square_kilometers"},
+        "perimeter_km": {"value": perimeter_m / 1_000, "unit": "kilometers"}
+    }
+
+
+def calculate_geometry_for_ui(file_url: str) -> tuple[str, str]:
+    """
+    Main calculation logic for the Gradio UI.
+    Formats the data from calculate_geometry_data into human-readable strings.
+    """
+    if not file_url or not file_url.strip():
+        return "Error: No URL provided.", ""
+    try:
+        data = calculate_geometry_data(file_url)
+        area_str = f"{data['area']['value']:,.2f} sq meters ({data['area_km2']['value']:,.2f} km²)"
+        perimeter_str = f"{data['perimeter']['value']:,.2f} meters ({data['perimeter_km']['value']:,.2f} km)"
         return area_str, perimeter_str
     except Exception as e:
         return f"An error occurred: {e}", ""
 
+# Initialize the FastAPI app first
+app = FastAPI()
+
+# --- NEW: Add a dedicated API endpoint ---
+@app.get("/api/geometry")
+def get_geometry_api(file_url: str):
+    """
+    API endpoint to calculate geometry from a KML/GeoJSON file URL.
+    Returns data in JSON format.
+    """
+    if not file_url:
+        raise HTTPException(status_code=400, detail="Missing 'file_url' query parameter.")
+    try:
+        # Decode the URL in case it's URL-encoded
+        decoded_url = unquote(file_url)
+        data = calculate_geometry_data(decoded_url)
+        return data
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 
-# --- New Gradio Interface using Blocks for more control ---
+# --- Gradio Interface using Blocks for more control ---
 with gr.Blocks() as demo:
     gr.Markdown(
         "# Polygon Area & Perimeter Calculator 🗺️\n"
         "Enter the public Google Drive URL of a KML or GeoJSON file, or load this page with "
         "`?file_url=<your_url>` to process automatically."
     )
-
+    # ... (rest of the Gradio UI code is the same)
     with gr.Column():
         url_input = gr.Textbox(
             label="Google Drive KML/GeoJSON File URL",
@@ -123,38 +150,29 @@ with gr.Blocks() as demo:
         inputs=url_input
     )
 
-    # This function runs when the page loads to check for a URL query parameter
     def process_url_on_load(request: gr.Request):
         file_url = request.query_params.get("file_url")
         if file_url:
-            area, perimeter = calculate_geometry(file_url)
-            # Return a dictionary to update the components
+            area, perimeter = calculate_geometry_for_ui(file_url)
             return {
                 url_input: file_url,
                 area_output: area,
                 perimeter_output: perimeter
             }
-        # If no URL, return empty values
-        return {
-            url_input: "",
-            area_output: "",
-            perimeter_output: ""
-        }
-
-    # Define the event handlers
+        return { url_input: "", area_output: "", perimeter_output: "" }
+
     submit_button.click(
-        fn=calculate_geometry,
+        fn=calculate_geometry_for_ui,
         inputs=url_input,
         outputs=[area_output, perimeter_output]
     )
     
     demo.load(
         fn=process_url_on_load,
-        inputs=None, # The 'load' event doesn't take direct component inputs
+        inputs=None,
         outputs=[url_input, area_output, perimeter_output]
     )
 
-# Initialize the FastAPI app and mount the Gradio interface
-app = FastAPI()
-app = gr.mount_gradio_app(app, demo, path="/")
 
+# Mount the Gradio app onto the FastAPI app
+app = gr.mount_gradio_app(app, demo, path="/")