Support URL Input

app.py

@@ -18,7 +18,7 @@ import kml2geojson
 import folium
 import xml.etree.ElementTree as ET
 
-# --- Helper Functions from functions.py ---
+# --- Helper Functions ---
 
 def one_time_setup():
     """Initializes the Earth Engine API."""
@@ -42,35 +42,63 @@ def one_time_setup():
             # In a real app, you might want to show an error to the user here
             # For this Gradio app, we'll let it proceed and fail gracefully later if EE is needed.
 
+def _process_spatial_data(data_bytes):
+    """Core function to process bytes of a KML or GeoJSON file."""
+    # Read the first few bytes to determine file type without consuming the stream
+    start_of_file = data_bytes.read(100)
+    data_bytes.seek(0)  # Reset stream position
 
-def get_gdf_from_file(file_obj):
-    """Reads a KML or GeoJSON file and returns a GeoDataFrame."""
-    bytes_data = BytesIO(file_obj)
-    # Read the start of the file to check if it's XML (KML)
-    # We need to be careful not to consume the stream
-    start_of_file = bytes_data.read(100)
-    bytes_data.seek(0) # Reset pointer
-
-    if start_of_file.strip().startswith(b'<?xml'):
+    # Check if the file is KML (XML-based)
+    if start_of_file.strip().lower().startswith(b'<?xml'):
         try:
-            # Use a temporary file to work with kml2geojson which might expect a file path
-            with open("temp.kml", "wb") as f:
-                f.write(bytes_data.read())
-            geojson = kml2geojson.convert("temp.kml")
-            features = geojson[0]["features"]
-            epsg = 4326
-            input_gdf = gpd.GeoDataFrame.from_features(features, crs=f"EPSG:{epsg}")
-            os.remove("temp.kml")
+            geojson_data = kml2geojson.convert(data_bytes)
+            if not geojson_data or not geojson_data[0].get("features"):
+                raise ValueError("KML file is empty or has no features.")
+            features = geojson_data[0]["features"]
+            input_gdf = gpd.GeoDataFrame.from_features(features, crs="EPSG:4326")
         except Exception as e:
-            raise ValueError(f"Failed to process KML file: {e}")
+            raise ValueError(f"Failed to process KML data: {e}")
+    # Otherwise, assume it's a format geopandas can read
     else:
         try:
-            input_gdf = gpd.read_file(bytes_data)
+            input_gdf = gpd.read_file(data_bytes)
         except Exception as e:
-            raise ValueError(f"Failed to read GeoJSON/Shapefile: {e}")
-
+            raise ValueError(f"Failed to read GeoJSON or other vector data: {e}")
     return input_gdf
 
+def get_gdf_from_file(file_obj):
+    """Reads a KML or GeoJSON file from a Gradio file object and returns a GeoDataFrame."""
+    if file_obj is None:
+        return None
+    with open(file_obj.name, 'rb') as f:
+        data_bytes = BytesIO(f.read())
+    return _process_spatial_data(data_bytes)
+
+def get_gdf_from_url(url):
+    """Downloads and reads a KML/GeoJSON from a URL."""
+    if not url or not url.strip():
+        return None
+    
+    # Handle Google Drive URLs
+    if "drive.google.com" in url:
+        if "/file/d/" in url:
+            file_id = url.split('/d/')[1].split('/')[0]
+        elif "open?id=" in url:
+            file_id = url.split('open?id=')[1].split('&')[0]
+        else:
+            raise ValueError("Unsupported Google Drive URL format. Please provide a direct link or a shareable link with 'open?id=' or '/file/d/'.")
+        download_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+    else:
+        download_url = url
+
+    try:
+        response = requests.get(download_url, timeout=30)
+        response.raise_for_status()
+        data_bytes = BytesIO(response.content)
+        return _process_spatial_data(data_bytes)
+    except requests.exceptions.RequestException as e:
+        raise ValueError(f"Failed to download file from URL: {e}")
+
 
 def find_best_epsg(geometry):
     """Finds the most suitable EPSG code for a given geometry based on its centroid."""
@@ -231,14 +259,20 @@ def add_indices(image, nir_band, red_band, blue_band, green_band, evi_vars):
 one_time_setup()
 WAYBACK_DF = get_wayback_data()
 
-def process_and_display(file_obj, buffer_m, progress=gr.Progress()):
-    """Main function to process the uploaded file and generate initial outputs."""
-    if file_obj is None:
-        return None, "Please upload a KML or GeoJSON file.", None, None, None
+def process_and_display(file_obj, url_str, buffer_m, progress=gr.Progress()):
+    """Main function to process the uploaded file or URL and generate initial outputs."""
+    if file_obj is None and not (url_str and url_str.strip()):
+        return None, "Please upload a file or provide a URL.", None, None, None
 
     progress(0, desc="Reading and processing geometry...")
     try:
-        input_gdf = get_gdf_from_file(file_obj)
+        if file_obj is not None:
+            # Prioritize file upload
+            input_gdf = get_gdf_from_file(file_obj)
+        else:
+            # Use URL if file is not provided
+            input_gdf = get_gdf_from_url(url_str)
+
         input_gdf = preprocess_gdf(input_gdf)
 
         # Find the first valid polygon
@@ -250,7 +284,7 @@ def process_and_display(file_obj, buffer_m, progress=gr.Progress()):
                 break
 
         if geometry_gdf is None:
-            return None, "No valid polygon found in the uploaded file.", None, None, None
+            return None, "No valid polygon found in the provided file or URL.", None, None, None
 
         geometry_gdf = to_best_crs(geometry_gdf)
 
@@ -294,7 +328,6 @@ def process_and_display(file_obj, buffer_m, progress=gr.Progress()):
     })
 
     # Save geometry data for later use
-    # In Gradio, we pass data between functions instead of using session state
     geometry_json = geometry_gdf.to_json()
     buffer_geometry_json = buffer_geometry_gdf.to_json()
 
@@ -318,9 +351,7 @@ def calculate_indices(
         # Convert to EE geometry
         ee_geometry = ee.Geometry(json.loads(geometry_gdf.to_crs(4326).to_json())['features'][0]['geometry'])
         buffer_ee_geometry = ee.Geometry(json.loads(buffer_geometry_gdf.to_crs(4326).to_json())['features'][0]['geometry'])
-        ee_fc = ee.FeatureCollection(ee_geometry)
-        buffer_ee_fc = ee.FeatureCollection(buffer_ee_geometry)
-
+        
         # Date ranges
         start_day, start_month = date_range[0].day, date_range[0].month
         end_day, end_month = date_range[1].day, date_range[1].month
@@ -361,7 +392,7 @@ def calculate_indices(
             return "No satellite imagery found for the selected dates.", None, None, None
 
         result_df = pd.DataFrame(result_rows).set_index('daterange')
-        result_df.index = result_df.index.str.split('_').str[0] # Use start year as index for plotting
+        result_df.index = result_df.index.str.split('-').str[0] # Use start year as index for plotting
 
         # Create plots
         plots = []
@@ -394,10 +425,12 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
 
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("## 1. Upload Geometry")
+            gr.Markdown("## 1. Provide Input Geometry")
+            gr.Markdown("Use either file upload OR a URL.")
             file_input = gr.File(label="Upload KML/GeoJSON File", file_types=[".kml", ".geojson"])
+            url_input = gr.Textbox(label="Or Provide File URL", placeholder="e.g., https://.../my_file.kml")
             buffer_input = gr.Number(label="Buffer (meters)", value=50)
-            process_button = gr.Button("Process File", variant="primary")
+            process_button = gr.Button("Process Input", variant="primary")
             info_box = gr.Textbox(label="Status", interactive=False)
 
             with gr.Accordion("Advanced Settings", open=False):
@@ -415,7 +448,6 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
                     evi_c = gr.Number(label="C", value=2.4)
 
                 gr.Markdown("### Date Range")
-                # Gradio doesn't have a direct date range picker, so we use two date inputs
                 today = datetime.now()
                 date_start_input = gr.Textbox(label="Start Date (MM-DD)", value="11-15")
                 date_end_input = gr.Textbox(label="End Date (MM-DD)", value="12-15")
@@ -424,25 +456,29 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
                     min_year_input = gr.Number(label="Start Year", value=2019, precision=0)
                     max_year_input = gr.Number(label="End Year", value=today.year, precision=0)
 
-
             calculate_button = gr.Button("Calculate Vegetation Indices", variant="primary")
 
-
         with gr.Column(scale=2):
             gr.Markdown("## 2. Results")
             stats_output = gr.DataFrame(label="Geometry Metrics")
             map_output = gr.HTML(label="Map View")
             results_info_box = gr.Textbox(label="Calculation Status", interactive=False)
             timeseries_table = gr.DataFrame(label="Time Series Data")
-            with gr.Blocks() as plot_output_blocks:
-                 gr.Markdown("### Time Series Plots")
-                 # This will be populated dynamically
-            # We will handle plot display logic in the backend
+            plot_output = gr.Plot(label="Time Series Plot")
+
 
     # --- Event Handlers ---
+    
+    def process_on_load(request: gr.Request):
+        """Checks for a 'file_url' query parameter when the app loads and populates the URL input field."""
+        file_url = request.query_params.get("file_url")
+        return file_url if file_url else ""
+
+    demo.load(process_on_load, None, url_input)
+
     process_button.click(
         fn=process_and_display,
-        inputs=[file_input, buffer_input],
+        inputs=[file_input, url_input, buffer_input],
         outputs=[map_output, info_box, stats_output, geometry_data, buffer_geometry_data]
     )
 
@@ -451,30 +487,20 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Kamlan: KML Analyzer") as demo:
                           min_year, max_year, progress=gr.Progress()):
         """Wrapper to parse inputs before calling the main calculation function."""
         try:
-            # Parse EVI vars
             evi_vars = {'G': g, 'C1': c1, 'C2': c2, 'L': l, 'C': c}
-            # Parse dates - we ignore the year part from the string
             start_month, start_day = map(int, start_date_str.split('-'))
             end_month, end_day = map(int, end_date_str.split('-'))
-            # Use a dummy year, the actual year is handled in the loop
             date_range = (datetime(2000, start_month, start_day), datetime(2000, end_month, end_day))
 
             error, df, plots, msg = calculate_indices(
                 geometry_json, buffer_geometry_json, veg_indices,
                 evi_vars, date_range, int(min_year), int(max_year), progress
             )
-            # Gradio can't directly update a variable number of plots.
-            # A workaround is to return a list and handle it, or create a fixed number of plot outputs.
-            # For simplicity, we'll return the first plot if it exists.
             first_plot = plots[0] if plots else None
             return error, df, first_plot, msg
         except Exception as e:
             return f"Input error: {e}", None, None, "Failed"
 
-
-    # We create a single plot output for simplicity. For multiple plots, a dynamic UI update is more complex.
-    plot_output = gr.Plot(label="Time Series Plot")
-
     calculate_button.click(
         fn=calculate_wrapper,
         inputs=[