Update app.py

app.py

@@ -13,8 +13,7 @@ import cartopy.crs as ccrs
 import cartopy.feature as cfeature
 import base64
 import io
-from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Tuple
 import gradio as gr
 import logging
 
@@ -160,6 +159,7 @@ class EarthquakeDataService:
                 image_base64 = base64.b64encode(buffer.getvalue()).decode()
                 result["map_image_base64"] = image_base64
                 buffer.close()
+                plt.close(fig) # Close the figure to free memory
                 
             return result
 
@@ -282,7 +282,7 @@ class EarthquakeMCPServer:
                         "capabilities": {"tools": {}},
                         "serverInfo": {
                             "name": "earthquake-data-server",
-                            "version": "1.1.0"
+                            "version": "1.2.0" # Version bump
                         }
                     }
                 }
@@ -305,11 +305,9 @@ class EarthquakeMCPServer:
                 
                 if tool_name == "query_earthquakes":
                     result = await self.data_service.query_earthquakes_data(**arguments)
-                    # Remove dataframe for JSON serialization
                     result.pop("dataframe", None)
                 elif tool_name == "create_earthquake_map":
                     result = await self.data_service.create_earthquake_map(**arguments)
-                    # Remove figure for JSON serialization
                     result.pop("figure", None)
                 elif tool_name == "get_earthquake_stats":
                     result = await self.data_service.get_earthquake_stats(**arguments)
@@ -341,7 +339,7 @@ class EarthquakeMCPServer:
                 }
                 
         except Exception as e:
-            logger.error(f"Error handling MCP request: {e}")
+            logger.error(f"Error handling MCP request: {e}", exc_info=True)
             return {
                 "jsonrpc": "2.0",
                 "id": request.get("id", 0),
@@ -349,45 +347,39 @@ class EarthquakeMCPServer:
             }
 
 
-# Global data service instance
+# Global instances
 data_service = EarthquakeDataService()
 mcp_server = EarthquakeMCPServer(data_service)
 
 # --- Gradio Interface Functions ---
+
 async def fetch_and_plot_data(
     start_date: str, end_date: str, minimum_magnitude: float
 ) -> Tuple[pd.DataFrame, Any]:
-    """Gradio interface function for fetching and plotting data."""
+    """Gradio interface function for fetching data and creating a plot."""
     try:
-        # Create map which also queries the data internally
-        map_result = await data_service.create_earthquake_map(
+        query_result = await data_service.query_earthquakes_data(
             start_date=start_date,
             end_date=end_date,
             minimum_magnitude=minimum_magnitude
         )
         
-        # Query data again to get the dataframe for the table
-        query_result = await data_service.query_earthquakes_data(
+        df = query_result.get("dataframe", pd.DataFrame())
+        
+        if query_result.get("count", 0) == 0:
+            return df, None
+
+        map_result = await data_service.create_earthquake_map(
             start_date=start_date,
             end_date=end_date,
             minimum_magnitude=minimum_magnitude
         )
         
-        df = query_result.get("dataframe", pd.DataFrame())
         figure = map_result.get("figure")
-
         return df, figure
         
     except Exception as e:
-        logger.error(f"Error in fetch_and_plot_data: {e}")
-        return pd.DataFrame({"Error": [str(e)]}), None
-
-def gradio_fetch_and_plot_data(*args):
-    """Synchronous wrapper for Gradio."""
-    try:
-        return asyncio.run(fetch_and_plot_data(*args))
-    except Exception as e:
-        logger.error(f"Error running async fetch_and_plot_data: {e}")
+        logger.error(f"Error in fetch_and_plot_data: {e}", exc_info=True)
         return pd.DataFrame({"Error": [str(e)]}), None
 
 
@@ -397,22 +389,22 @@ async def handle_mcp_request_gradio(request_json: str) -> str:
         request = json.loads(request_json)
         response = await mcp_server.handle_mcp_request(request)
         return json.dumps(response, indent=2, ensure_ascii=False)
-    except Exception as e:
+    except json.JSONDecodeError as e:
+        logger.error(f"JSON Parse Error: {e}")
         error_response = {
             "jsonrpc": "2.0",
             "id": None,
-            "error": {"code": -32700, "message": f"Parse error: {str(e)}"}
+            "error": {"code": -32700, "message": f"Parse error: {e}"}
         }
         return json.dumps(error_response, indent=2)
-
-def gradio_handle_mcp_request(request_json: str) -> str:
-    """Synchronous wrapper for MCP requests in Gradio."""
-    try:
-        return asyncio.run(handle_mcp_request_gradio(request_json))
     except Exception as e:
-        logger.error(f"Error running async handle_mcp_request_gradio: {e}")
-        return json.dumps({"error": str(e)})
-
+        logger.error(f"Error in handle_mcp_request_gradio: {e}", exc_info=True)
+        error_response = {
+            "jsonrpc": "2.0",
+            "id": None, # ID may not be available if parsing failed
+            "error": {"code": -32603, "message": f"Internal server error: {e}"}
+        }
+        return json.dumps(error_response, indent=2)
 
 # --- Gradio Interface ---
 with gr.Blocks(title="Earthquake Data MCP Server", theme=gr.themes.Soft()) as app:
@@ -442,8 +434,9 @@ with gr.Blocks(title="Earthquake Data MCP Server", theme=gr.themes.Soft()) as ap
                 with gr.Column(scale=3):
                     output_df = gr.DataFrame(label="Filtered Results")
             
+            # CORRECTED: Call the async function directly
             filter_button.click(
-                fn=gradio_fetch_and_plot_data,
+                fn=fetch_and_plot_data,
                 inputs=[
                     start_date_input, end_date_input, minimum_magnitude_input
                 ],
@@ -453,11 +446,7 @@ with gr.Blocks(title="Earthquake Data MCP Server", theme=gr.themes.Soft()) as ap
         # MCP Interface Tab
         with gr.TabItem("🔌 MCP Interface"):
             gr.Markdown("### Model Context Protocol (MCP) Interface")
-            gr.Markdown("""
-            This tab allows you to interact with the MCP server directly. Send JSON-RPC requests to test the MCP functionality.
-            
-            **Available Tools:** `query_earthquakes`, `create_earthquake_map`, `get_earthquake_stats`
-            """)
+            gr.Markdown("Interact with the MCP server directly. **Available Tools:** `query_earthquakes`, `create_earthquake_map`, `get_earthquake_stats`")
             
             with gr.Row():
                 with gr.Column():
@@ -469,26 +458,21 @@ with gr.Blocks(title="Earthquake Data MCP Server", theme=gr.themes.Soft()) as ap
                     mcp_submit_button = gr.Button("📤 Send MCP Request", variant="primary")
                 
                 with gr.Column():
-                    mcp_response_output = gr.Code(
-                        label="MCP Response",
-                        language="json"
-                    )
+                    mcp_response_output = gr.Code(label="MCP Response", language="json")
             
+            # CORRECTED: Call the async function directly
             mcp_submit_button.click(
-                fn=gradio_handle_mcp_request,
+                fn=handle_mcp_request_gradio,
                 inputs=[mcp_request_input],
                 outputs=[mcp_response_output]
             )
             
-            # Example requests
             gr.Markdown("#### Example Requests:")
-            
             example_requests = [
                 ("List Tools", '{\n  "jsonrpc": "2.0",\n  "id": 2,\n  "method": "tools/list",\n  "params": {}\n}'),
                 ("Query Earthquakes", '{\n  "jsonrpc": "2.0",\n  "id": 3,\n  "method": "tools/call",\n  "params": {\n    "name": "query_earthquakes",\n    "arguments": {\n      "start_date": "2024-04-01",\n      "end_date": "2024-04-30",\n      "minimum_magnitude": 5.0\n    }\n  }\n}'),
                 ("Get Statistics", '{\n  "jsonrpc": "2.0",\n  "id": 4,\n  "method": "tools/call",\n  "params": {\n    "name": "get_earthquake_stats",\n    "arguments": {\n      "start_date": "2024-01-01",\n      "end_date": "2024-06-30",\n      "minimum_magnitude": 6.0\n    }\n  }\n}')
             ]
-            
             for title, request in example_requests:
                 with gr.Accordion(title, open=False):
                     gr.Code(value=request, language="json")
@@ -497,9 +481,7 @@ with gr.Blocks(title="Earthquake Data MCP Server", theme=gr.themes.Soft()) as ap
         with gr.TabItem("📚 API Documentation"):
             gr.Markdown("""
             # API Documentation
-            
             ## MCP Server Tools
-            
             ### 1. query_earthquakes
             Query earthquake data.
             **Parameters:**
@@ -523,15 +505,10 @@ with gr.Blocks(title="Earthquake Data MCP Server", theme=gr.themes.Soft()) as ap
 
 # --- Main Application ---
 if __name__ == "__main__":
-    # Check if running in Hugging Face Spaces
     import os
     port = int(os.environ.get("PORT", 7860))
     
     logger.info("Starting Earthquake Data MCP Server...")
     logger.info(f"Server will be available at: http://0.0.0.0:{port}")
     
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=port,
-        mcp_server=True
-    )
+    app.launch(server_name="0.0.0.0", server_port=port)