Update app.py

app.py

@@ -7,12 +7,19 @@ import json
 import pickle
 import os
 from typing import Dict, List, Any
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import threading
 
 os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
 
 print("🚀 Starting Eco Finder API...")
 
+# Initialize Flask app
+flask_app = Flask(__name__)
+CORS(flask_app)  # Enable CORS for all routes
+
 # Configuration
 try:
     import tensorflow as tf
@@ -90,11 +97,104 @@ train_medians = feature_stats.get("train_medians", {})
 
 BASE = "https://exoplanetarchive.ipac.caltech.edu/cgi-bin/nstedAPI/nph-nstedAPI"
 
-# ==================== FUNCTIONS FOR GRADIO ====================
+# ==================== FLASK API ENDPOINTS ====================
+
+@flask_app.route('/')
+def home():
+    return jsonify({
+        "message": "Eco Finder API - Exoplanet Classification",
+        "version": "1.0.0",
+        "endpoints": {
+            "health": "/health (GET)",
+            "predict": "/predict (POST)",
+            "predict_batch": "/predict-batch (POST)",
+            "features": "/features (GET)"
+        }
+    })
+
+@flask_app.route('/health', methods=['GET'])
+def health():
+    return jsonify({
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "tensorflow_available": TENSORFLOW_AVAILABLE,
+        "features_count": len(feature_columns)
+    })
+
+@flask_app.route('/predict', methods=['POST'])
+def api_predict():
+    """REST API endpoint for single prediction"""
+    try:
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({"error": "No JSON data provided"}), 400
+        
+        # Use default values if parameters are missing
+        features = {}
+        for feature in feature_columns:
+            features[feature] = data.get(feature, train_medians.get(feature, 0))
+        
+        # Make prediction
+        result = predict_single(features)
+        
+        if "error" in result:
+            return jsonify(result), 500
+        
+        return jsonify(result)
+        
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@flask_app.route('/predict-batch', methods=['POST'])
+def api_predict_batch():
+    """REST API endpoint for batch predictions"""
+    try:
+        data = request.get_json()
+        
+        if not data or 'objects' not in data:
+            return jsonify({"error": "No 'objects' array provided"}), 400
+        
+        predictions = []
+        for obj in data['objects']:
+            features = {}
+            for feature in feature_columns:
+                features[feature] = obj.get(feature, train_medians.get(feature, 0))
+            
+            result = predict_single(features)
+            predictions.append(result)
+        
+        return jsonify({"predictions": predictions})
+        
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@flask_app.route('/features', methods=['GET'])
+def api_features():
+    """Get information about available features"""
+    return jsonify({
+        "feature_columns": feature_columns,
+        "train_medians": train_medians,
+        "feature_descriptions": {
+            "koi_period": "Orbital period (days)",
+            "koi_duration": "Transit duration (hours)",
+            "koi_depth": "Transit depth (ppm)",
+            "koi_prad": "Planetary radius (Earth radii)",
+            "koi_srad": "Stellar radius (Solar radii)",
+            "koi_teq": "Equilibrium temperature (K)",
+            "koi_steff": "Stellar effective temperature (K)",
+            "koi_slogg": "Stellar surface gravity (log g)",
+            "koi_smet": "Stellar metallicity ([Fe/H])",
+            "koi_kepmag": "TESS magnitude",
+            "koi_model_snr": "Signal-to-noise ratio",
+            "koi_num_transits": "Number of transits"
+        }
+    })
 
+# ==================== PREDICTION FUNCTIONS ====================
 
 def predict_single(features: Dict) -> Dict:
-    """Function to predict a single object - USED BY GRADIO"""
+    """Function to predict a single object"""
     try:
         if model is None or scaler is None or label_encoder is None:
             return {"error": "Model not available"}
@@ -244,7 +344,7 @@ def predict_toi_realtime():
             if "error" not in result:
                 results.append(
                     {
-                        "TOI": row.get("toi", f"tOI-{idx}"),
+                        "TOI": row.get("toi", f"TOI-{idx}"),
                         "Disposition": row.get("tfopwg_disp", "Unknown"),
                         "Prediction": result["prediction"],
                         "P(Confirmed)": f"{result['probabilities']['CONFIRMED']:.3f}",
@@ -311,19 +411,22 @@ def predict_manual(
 
 with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
     gr.Markdown("# 🌌 Eco Finder API")
-    gr.Markdown("Exoplanet classifier")
+    gr.Markdown("Exoplanet classifier with REST API")
 
-    with gr.Tab("🎯 API Prediction"):
-        gr.Markdown("### Endpoint for frontend consumption")
+    with gr.Tab("🎯 API Documentation"):
         gr.Markdown("""
-        **URL:** `https://jarpalucas-echo-finder-api.hf.space/api/predict`
+        ## REST API Endpoints
         
-        **Method:** POST
-        **Content-Type:** application/json
+        ### Health Check
+        **GET** `/health`
+        ```bash
+        curl -X GET "https://your-domain/health"
+        ```
         
-        **Usage example with curl:**
+        ### Single Prediction
+        **POST** `/predict`
         ```bash
-        curl -X POST "https://jarpalucas-echo-finder-api.hf.space/api/predict" \\
+        curl -X POST "https://your-domain/predict" \\
           -H "Content-Type: application/json" \\
           -d '{
             "koi_period": 10.0,
@@ -340,9 +443,51 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
             "koi_num_transits": 3.0
           }'
         ```
+        
+        ### Batch Predictions
+        **POST** `/predict-batch`
+        ```bash
+        curl -X POST "https://your-domain/predict-batch" \\
+          -H "Content-Type: application/json" \\
+          -d '{
+            "objects": [
+              {"koi_period": 10.0, "koi_duration": 5.0, ...},
+              {"koi_period": 15.0, "koi_duration": 6.0, ...}
+            ]
+          }'
+        ```
+        
+        ### Features Information
+        **GET** `/features`
+        ```bash
+        curl -X GET "https://your-domain/features"
+        ```
+        
+        ### JavaScript Example
+        ```javascript
+        async function predictExoplanet(features) {
+          const response = await fetch('/predict', {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(features)
+          });
+          return await response.json();
+        }
+        
+        // Usage
+        const result = await predictExoplanet({
+          koi_period: 10.0,
+          koi_duration: 5.0,
+          // ... all parameters
+        });
+        ```
         """)
 
-        # Inputs to test the API locally
+    with gr.Tab("🔧 Test Interface"):
+        gr.Markdown("Test the prediction model with this interface")
+        
         with gr.Row():
             with gr.Column():
                 period = gr.Number(label="koi_period", value=10.0)
@@ -360,10 +505,10 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
                 snr = gr.Number(label="koi_model_snr", value=10.0)
                 num_transits = gr.Number(label="koi_num_transits", value=3.0)
 
-        api_btn = gr.Button("🚀 Test Prediction")
-        api_output = gr.JSON()
+        test_btn = gr.Button("🚀 Test Prediction")
+        test_output = gr.JSON()
 
-        api_btn.click(
+        test_btn.click(
             fn=predict_from_dict,
             inputs=[
                 period,
@@ -379,7 +524,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
                 snr,
                 num_transits,
             ],
-            outputs=api_output,
+            outputs=test_output,
         )
 
     with gr.Tab("🔭 Real-time TOI"):
@@ -388,32 +533,30 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
         toi_output = gr.Markdown()
         toi_btn.click(predict_toi_realtime, outputs=toi_output)
 
-    with gr.Tab("📊 Manual Interface"):
-        gr.Markdown("Manual interface for predictions")
-        manual_btn = gr.Button("🎯 Predict")
-        manual_output = gr.Markdown()
-        manual_btn.click(
-            fn=predict_manual,
-            inputs=[
-                period,
-                duration,
-                depth,
-                prad,
-                srad,
-                teq,
-                steff,
-                slogg,
-                smet,
-                kepmag,
-                snr,
-                num_transits,
-            ],
-            outputs=manual_output,
-        )
+# ==================== APPLICATION STARTUP ====================
+
+def run_flask():
+    """Run Flask app on port 5000"""
+    flask_app.run(host='0.0.0.0', port=5000, debug=False)
 
-print("🎉 Application started successfully!")
-print("🌐 Interface available at: /")
-print("🔗 API endpoint available at: /api/predict")
+def run_gradio():
+    """Run Gradio app on port 7860"""
+    demo.launch(server_name='0.0.0.0', server_port=7860, share=False)
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    print("🎉 Application started successfully!")
+    print("🌐 Gradio Interface available at: http://0.0.0.0:7860")
+    print("🔗 REST API available at: http://0.0.0.0:5000")
+    print("📚 API Documentation:")
+    print("   GET  /health")
+    print("   POST /predict")
+    print("   POST /predict-batch")
+    print("   GET  /features")
+    
+    # Start both servers
+    flask_thread = threading.Thread(target=run_flask)
+    flask_thread.daemon = True
+    flask_thread.start()
+    
+    # Run Gradio in main thread
+    run_gradio()