Upload app.py

app.py

@@ -11,42 +11,42 @@ from typing import Dict, List, Any
 os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
 
-print("🚀 Iniciando Eco Finder API...")
+print("🚀 Starting Eco Finder API...")
 
-# Configuración
+# Configuration
 try:
     import tensorflow as tf
     print(f"✅ TensorFlow version: {tf.__version__}")
     from tensorflow.keras.models import load_model
     TENSORFLOW_AVAILABLE = True
 except ImportError as e:
-    print(f"❌ TensorFlow no disponible: {e}")
+    print(f"❌ TensorFlow not available: {e}")
     TENSORFLOW_AVAILABLE = False
 
-# Cargar recursos
+# Load resources
 def load_resources():
     try:
         with open("feature_stats.json", "r") as f:
             feature_stats = json.load(f)
-        print("✅ Feature stats cargado")
+        print("✅ Feature stats loaded")
             
         with open("scaler.pkl", "rb") as f:
             scaler = pickle.load(f)
-        print("✅ Scaler cargado")
+        print("✅ Scaler loaded")
             
         with open("label_encoder.pkl", "rb") as f:
             label_encoder = pickle.load(f)
-        print("✅ Label encoder cargado")
+        print("✅ Label encoder loaded")
         
         model = None
         if TENSORFLOW_AVAILABLE:
             model = load_model("modulo_tabular.h5")
-            print("✅ Modelo cargado")
+            print("✅ Model loaded")
         
         return model, scaler, label_encoder, feature_stats
         
     except Exception as e:
-        print(f"❌ Error cargando recursos: {str(e)}")
+        print(f"❌ Error loading resources: {str(e)}")
         feature_stats = {
             "feature_columns": [
                 "koi_period", "koi_duration", "koi_depth", "koi_prad", 
@@ -62,28 +62,28 @@ def load_resources():
         }
         return None, None, None, feature_stats
 
-# Cargar recursos
+# Load resources
 model, scaler, label_encoder, feature_stats = load_resources()
 feature_columns = feature_stats.get("feature_columns", [])
 train_medians = feature_stats.get("train_medians", {})
 
 BASE = "https://exoplanetarchive.ipac.caltech.edu/cgi-bin/nstedAPI/nph-nstedAPI"
 
-# ==================== FUNCIONES PARA GRADIO ====================
+# ==================== FUNCTIONS FOR GRADIO ====================
 
 def predict_single(features: Dict) -> Dict:
-    """Función para predecir un solo objeto - USADA POR GRADIO"""
+    """Function to predict a single object - USED BY GRADIO"""
     try:
         if model is None or scaler is None or label_encoder is None:
-            return {"error": "Modelo no disponible"}
+            return {"error": "Model not available"}
         
-        # Crear array de características
+        # Create feature array
         input_features = []
         for feature in feature_columns:
             value = features.get(feature, train_medians.get(feature, 0))
             input_features.append(float(value))
         
-        # Predecir
+        # Predict
         input_array = np.array([input_features])
         X_input = scaler.transform(input_array)
         
@@ -114,7 +114,7 @@ def predict_from_dict(
     koi_steff: float, koi_slogg: float, koi_smet: float,
     koi_kepmag: float, koi_model_snr: float, koi_num_transits: float
 ) -> Dict:
-    """Wrapper que toma parámetros individuales y los convierte a dict"""
+    """Wrapper that takes individual parameters and converts them to dict"""
     features = {
         "koi_period": koi_period,
         "koi_duration": koi_duration,
@@ -131,29 +131,29 @@ def predict_from_dict(
     }
     return predict_single(features)
 
-def predict_toi_realtime():
-    """Función para TOI en tiempo real"""
+def predict_koi_realtime():
+    """Function for real-time KOI"""
     try:
         if model is None or scaler is None or label_encoder is None:
-            return "❌ Modelo no disponible"
+            return "❌ Model not available"
         
-        # Consultar API de exoplanetas
+        # Query exoplanet API
         where = ("(tfopwg_disp like 'PC' or tfopwg_disp like 'APC') "
                  "and (pl_orbper is not null or tce_period is not null)")
         
-        params = {"table": "toi", "where": where, "format": "csv"}
+        params = {"table": "koi", "where": where, "format": "csv"}
         resp = requests.get(BASE, params=params, timeout=60)
         resp.raise_for_status()
-        toi_df = pd.read_csv(io.StringIO(resp.text))
+        koi_df = pd.read_csv(io.StringIO(resp.text))
         
-        if toi_df.empty:
-            return "❌ No se encontraron objetos TOI"
+        if koi_df.empty:
+            return "❌ No KOI objects found"
         
-        # Tomar muestra
-        toi_sample = toi_df.sample(min(3, len(toi_df)), random_state=7)
-        toi_sample.columns = [c.strip().lower() for c in toi_sample.columns]
+        # Take sample
+        koi_sample = koi_df.sample(min(3, len(koi_df)), random_state=7)
+        koi_sample.columns = [c.strip().lower() for c in koi_sample.columns]
         
-        # Mapeo de sinónimos
+        # Synonym mapping
         candidates_map = {
             "koi_period": ["pl_orbper", "tce_period", "orbper", "period"],
             "koi_duration": ["pl_trandurh", "tce_duration", "tran_dur", "trandur", "duration", "dur"],
@@ -179,11 +179,11 @@ def predict_toi_realtime():
                     return found[0]
             return None
         
-        cols_set = set(toi_sample.columns)
+        cols_set = set(koi_sample.columns)
         results = []
         
-        for idx, row in toi_sample.iterrows():
-            # Preparar características
+        for idx, row in koi_sample.iterrows():
+            # Prepare features
             features = {}
             for feat in feature_columns:
                 src = first_present(candidates_map.get(feat, []), cols_set)
@@ -192,24 +192,24 @@ def predict_toi_realtime():
                 else:
                     features[feat] = train_medians.get(feat, 0)
             
-            # Predecir
+            # Predict
             result = predict_single(features)
             
             if "error" not in result:
                 results.append({
-                    "TOI": row.get('toi', f"TOI-{idx}"),
-                    "Disposición": row.get('tfopwg_disp', 'Unknown'),
-                    "Predicción": result['prediction'],
-                    "P(Confirmado)": f"{result['probabilities']['CONFIRMED']:.3f}",
-                    "P(Candidato)": f"{result['probabilities']['CANDIDATE']:.3f}",
-                    "P(Falso Positivo)": f"{result['probabilities']['FALSE_POSITIVE']:.3f}"
+                    "KOI": row.get('koi', f"KOI-{idx}"),
+                    "Disposition": row.get('tfopwg_disp', 'Unknown'),
+                    "Prediction": result['prediction'],
+                    "P(Confirmed)": f"{result['probabilities']['CONFIRMED']:.3f}",
+                    "P(Candidate)": f"{result['probabilities']['CANDIDATE']:.3f}",
+                    "P(False Positive)": f"{result['probabilities']['FALSE_POSITIVE']:.3f}"
                 })
         
         if not results:
-            return "❌ No se pudieron generar predicciones"
+            return "❌ Could not generate predictions"
         
         result_df = pd.DataFrame(results)
-        return f"**Predicciones TOI:**\n\n{result_df.to_markdown(index=False)}"
+        return f"**KOI Predictions:**\n\n{result_df.to_markdown(index=False)}"
         
     except Exception as e:
         return f"❌ Error: {str(e)}"
@@ -217,7 +217,7 @@ def predict_toi_realtime():
 def predict_manual(
     period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits
 ):
-    """Función para predicción manual en Gradio"""
+    """Function for manual prediction in Gradio"""
     try:
         result = predict_from_dict(
             period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits
@@ -226,7 +226,7 @@ def predict_manual(
         if "error" in result:
             return f"❌ {result['error']}"
         
-        output = f"**Predicción:** {result['prediction']}\n\n**Probabilidades:**\n"
+        output = f"**Prediction:** {result['prediction']}\n\n**Probabilities:**\n"
         for clase, prob in result['probabilities'].items():
             output += f"- {clase}: {prob:.3f}\n"
             
@@ -235,21 +235,21 @@ def predict_manual(
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
-# ==================== INTERFAZ GRADIO ====================
+# ==================== GRADIO INTERFACE ====================
 
 with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
     gr.Markdown("# 🌌 Eco Finder API")
-    gr.Markdown("Clasificador de exoplanetas")
+    gr.Markdown("Exoplanet classifier")
     
-    with gr.Tab("🎯 Predicción API"):
-        gr.Markdown("### Endpoint para consumo desde frontend")
+    with gr.Tab("🎯 API Prediction"):
+        gr.Markdown("### Endpoint for frontend consumption")
         gr.Markdown("""
         **URL:** `https://jarpalucas-echo-finder-api.hf.space/api/predict`
         
-        **Método:** POST
+        **Method:** POST
         **Content-Type:** application/json
         
-        **Ejemplo de uso con curl:**
+        **Usage example with curl:**
         ```bash
         curl -X POST "https://jarpalucas-echo-finder-api.hf.space/api/predict" \\
           -H "Content-Type: application/json" \\
@@ -270,7 +270,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
         ```
         """)
         
-        # Inputs para probar la API localmente
+        # Inputs to test the API locally
         with gr.Row():
             with gr.Column():
                 period = gr.Number(label="koi_period", value=10.0)
@@ -288,7 +288,7 @@ 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("🚀 Probar Predicción")
+        api_btn = gr.Button("🚀 Test Prediction")
         api_output = gr.JSON()
         
         api_btn.click(
@@ -297,15 +297,15 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
             outputs=api_output
         )
     
-    with gr.Tab("🔭 TOI Tiempo Real"):
-        gr.Markdown("Predicciones de objetos TOI en tiempo real")
-        toi_btn = gr.Button("🔍 Analizar TOI")
-        toi_output = gr.Markdown()
-        toi_btn.click(predict_toi_realtime, outputs=toi_output)
+    with gr.Tab("🔭 Real-time KOI"):
+        gr.Markdown("Real-time KOI object predictions")
+        koi_btn = gr.Button("🔍 Analyze KOI")
+        koi_output = gr.Markdown()
+        koi_btn.click(predict_koi_realtime, outputs=koi_output)
     
-    with gr.Tab("📊 Interfaz Manual"):
-        gr.Markdown("Interfaz manual para predicciones")
-        manual_btn = gr.Button("🎯 Predecir")
+    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,
@@ -313,9 +313,9 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
             outputs=manual_output
         )
 
-print("🎉 Aplicación iniciada correctamente!")
-print("🌐 Interfaz disponible en: /")
-print("🔗 Endpoint API disponible en: /api/predict")
+print("🎉 Application started successfully!")
+print("🌐 Interface available at: /")
+print("🔗 API endpoint available at: /api/predict")
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)