Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,292 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+import tempfile
+import os
+from gradio_client import Client, handle_file
+from sklearn.ensemble import IsolationForest
+from PIL import Image
+import io
 
-"""
-# Welcome to Streamlit!
+st.set_page_config(
+    page_title="🛰️ Satellite Log Companion",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    page_icon="🛰️"
+)
+
+# Custom CSS for a clean mission-control look
+st.markdown("""
+<style>
+    .main {background-color: #0e1117;}
+    .stPlotlyChart {background-color: #1a1f2e; border-radius: 10px; padding: 10px;}
+    .kpi {font-size: 2rem; font-weight: bold; text-align: center;}
+</style>
+""", unsafe_allow_html=True)
+
+# ====================== SESSION STATE & CACHING ======================
+if "df" not in st.session_state:
+    st.session_state.df = None
+if "gradio_client" not in st.session_state:
+    st.session_state.gradio_client = None
+
+@st.cache_resource
+def get_gradio_client(space_url: str, hf_token: str = None):
+    try:
+        if hf_token:
+            client = Client.duplicate(space_url, hf_token=hf_token)
+        else:
+            client = Client(space_url)
+        return client
+    except Exception as e:
+        st.error(f"Failed to connect to Gradio: {e}")
+        return None
+
+@st.cache_data
+def load_sample_data():
+    """Synthetic realistic satellite telemetry with injected anomalies"""
+    dates = pd.date_range("2025-02-01", periods=500, freq="5min")
+    np.random.seed(42)
+    data = {
+        "timestamp": dates,
+        "temperature_C": np.random.normal(25, 5, 500).clip(10, 45),
+        "voltage_V": np.random.normal(28, 1, 500).clip(24, 32),
+        "signal_dB": np.random.normal(-90, 5, 500).clip(-110, -70),
+        "altitude_km": np.random.normal(400, 10, 500).clip(380, 420),
+        "error_rate": np.random.poisson(2, 500) / 1000,
+    }
+    df = pd.DataFrame(data)
+    # Inject anomalies
+    df.loc[100:105, "temperature_C"] += 25   # thermal spike
+    df.loc[250:255, "voltage_V"] -= 8        # power drop
+    df.loc[400:405, "signal_dB"] += 30       # signal surge
+    return df
+
+def parse_uploaded_file(uploaded):
+    if uploaded.name.endswith(".csv"):
+        return pd.read_csv(uploaded)
+    else:
+        st.warning("Only CSV supported for now. Your Gradio app can handle other formats.")
+        return None
+
+# ====================== SIDEBAR ======================
+with st.sidebar:
+    st.title("🛰️ Mission Control")
+    st.markdown("**Companion to your Gradio Satellite Log Analyzer**")
+
+    gradio_url = st.text_input(
+        "Your Gradio Analyzer Space URL",
+        value="https://yourusername-satellite-log-analyzer.hf.space",
+        help="Paste the full URL of your Gradio Space"
+    )
+
+    hf_token = st.text_input("HF Token (optional - for private/duplicated Gradio)", type="password")
+
+    if st.button("🔗 Connect to Gradio"):
+        st.session_state.gradio_client = get_gradio_client(gradio_url, hf_token)
+        if st.session_state.gradio_client:
+            st.success("Connected! Use the Gradio tab to analyze.")
+            st.session_state.gradio_client.view_api()  # shows in console/logs
+
+    st.divider()
+    if st.button("📥 Load Sample Satellite Telemetry"):
+        st.session_state.df = load_sample_data()
+        st.success("Sample data loaded (with injected anomalies)!")
+
+# ====================== TABS ======================
+tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs([
+    "🏠 Home", "📤 Upload & Parse", "🔍 Data Explorer",
+    "📈 Visualizations", "🕵️ Local Analysis", "🤖 Gradio Integration", "📊 Reports"
+])
+
+with tab1:
+    st.title("🛰️ Satellite Log Companion Dashboard")
+    st.markdown("""
+    This app **pairs perfectly** with your Gradio Satellite Log Analyzer.  
+    • Upload & explore raw telemetry  
+    • Interactive plots & local ML anomalies  
+    • One-click send to your Gradio app for deep AI analysis  
+    • Export professional reports  
+    """)
+    st.info("👈 Set your Gradio URL in the sidebar → then use the **Gradio Integration** tab")
+
+with tab2:
+    st.header("Upload Logs")
+    uploaded = st.file_uploader("Upload satellite log (CSV)", type=["csv"], accept_multiple_files=False)
+    if uploaded:
+        df = parse_uploaded_file(uploaded)
+        if df is not None:
+            st.session_state.df = df
+            st.success(f"Loaded {len(df)} rows • Columns: {list(df.columns)}")
+
+    if st.session_state.df is not None:
+        st.subheader("Preview")
+        st.dataframe(st.session_state.df.head(100), use_container_width=True)
+
+with tab3:
+    if st.session_state.df is None:
+        st.warning("Upload data or load sample first")
+    else:
+        st.header("Data Explorer")
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("Rows", len(st.session_state.df))
+            st.metric("Columns", len(st.session_state.df.columns))
+        with col2:
+            if "timestamp" in st.session_state.df.columns:
+                st.session_state.df["timestamp"] = pd.to_datetime(st.session_state.df["timestamp"], errors="coerce")
+                st.metric("Time Span", f"{st.session_state.df['timestamp'].min().date()} → {st.session_state.df['timestamp'].max().date()}")
+
+        st.dataframe(st.session_state.df.describe(), use_container_width=True)
+
+        # Column filter
+        cols = st.multiselect("Select columns to view", st.session_state.df.columns, default=st.session_state.df.columns[:6])
+        st.dataframe(st.session_state.df[cols], use_container_width=True)
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+with tab4:
+    if st.session_state.df is None:
+        st.warning("No data yet")
+    else:
+        st.header("Interactive Visualizations")
+        numeric_cols = st.session_state.df.select_dtypes(include=np.number).columns.tolist()
 
-In the meantime, below is an example of what you can do with just a few lines of code:
+        y_cols = st.multiselect("Telemetry parameters (Y-axis)", numeric_cols, default=numeric_cols[:3])
+        if "timestamp" in st.session_state.df.columns and y_cols:
+            fig = px.line(st.session_state.df, x="timestamp", y=y_cols, title="Telemetry Time Series")
+            st.plotly_chart(fig, use_container_width=True)
+
+        # Correlation heatmap
+        if len(numeric_cols) > 1:
+            corr = st.session_state.df[numeric_cols].corr()
+            fig_heat = px.imshow(corr, text_auto=True, aspect="auto", title="Parameter Correlation")
+            st.plotly_chart(fig_heat, use_container_width=True)
+
+        # If lat/lon present → map
+        if {"latitude", "longitude"}.issubset(st.session_state.df.columns):
+            st.map(st.session_state.df.rename(columns={"latitude":"lat", "longitude":"lon"}))
+
+with tab5:
+    if st.session_state.df is None:
+        st.warning("No data")
+    else:
+        st.header("Local Anomaly Detection")
+        numeric_cols = st.session_state.df.select_dtypes(include=np.number).columns.tolist()
+
+        method = st.radio("Detection method", ["Z-Score (simple)", "Isolation Forest (ML)"])
+
+        if method == "Z-Score (simple)":
+            threshold = st.slider("Z-Score threshold", 2.0, 5.0, 3.0)
+            for col in numeric_cols:
+                z = np.abs((st.session_state.df[col] - st.session_state.df[col].mean()) / st.session_state.df[col].std())
+                anomalies = z > threshold
+                st.session_state.df[f"{col}_anomaly"] = anomalies
+            st.success(f"Found anomalies in {sum(anomalies)} rows")
+            st.dataframe(st.session_state.df[st.session_state.df.filter(like="_anomaly").any(axis=1)])
+
+        else:  # Isolation Forest
+            if st.button("Run Isolation Forest"):
+                X = st.session_state.df[numeric_cols].fillna(0)
+                iso = IsolationForest(contamination=0.05, random_state=42)
+                preds = iso.fit_predict(X)
+                st.session_state.df["isolation_anomaly"] = preds == -1
+                st.success(f"Isolation Forest flagged {sum(preds == -1)} anomalies")
+                fig = px.scatter(st.session_state.df, x="timestamp" if "timestamp" in st.session_state.df else numeric_cols[0],
+                                 y=numeric_cols[0], color="isolation_anomaly", title="Anomalies Highlighted")
+                st.plotly_chart(fig, use_container_width=True)
+
+with tab6:
+    st.header("🤖 Send to Your Gradio Analyzer")
+    if st.session_state.gradio_client is None:
+        st.warning("Connect your Gradio Space in the sidebar first")
+    elif st.session_state.df is None:
+        st.warning("Load/upload data first")
+    else:
+        st.info("The app will save your current dataframe as CSV and send it to your Gradio Space.")
+
+        col1, col2 = st.columns([3,1])
+        with col1:
+            if st.button("🚀 Send Current Log to Gradio Analyzer", type="primary", use_container_width=True):
+                with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as tmp:
+                    st.session_state.df.to_csv(tmp.name, index=False)
+                    tmp_path = tmp.name
+
+                client = st.session_state.gradio_client
+
+                with st.spinner("Sending to Gradio... (may queue if busy)"):
+                    try:
+                        # Use submit for long-running satellite log jobs
+                        job = client.submit(
+                            log_file=handle_file(tmp_path),   # your Gradio likely has a file input named "log_file" or similar
+                            api_name="/predict"               # change if your function name is different (check view_api)
+                        )
+
+                        status_placeholder = st.empty()
+                        while not job.done():
+                            status = job.status()
+                            status_placeholder.info(f"Status: {status.code} | Queue: {getattr(status, 'rank', 'N/A')}")
+                            # st.progress would need polling, but this works
+
+                        result = job.result()
+
+                        st.success("Gradio analysis complete!")
+                        st.subheader("Gradio Results")
+                        # Flexible rendering of any output type(s)
+                        if isinstance(result, (list, tuple)):
+                            for i, out in enumerate(result):
+                                st.markdown(f"**Output {i+1}**")
+                                if isinstance(out, str):
+                                    st.markdown(out)
+                                elif isinstance(out, pd.DataFrame):
+                                    st.dataframe(out)
+                                elif isinstance(out, (bytes, io.BytesIO)):
+                                    st.image(out)
+                                elif isinstance(out, Image.Image):
+                                    st.image(out)
+                                else:
+                                    st.write(out)
+                        else:
+                            st.write(result)
+
+                    except Exception as e:
+                        st.error(f"Gradio call failed: {e}")
+                    finally:
+                        os.unlink(tmp_path)
+
+        st.caption("Tip: Open your Gradio Space in another tab to compare side-by-side")
+
+with tab7:
+    if st.session_state.df is None:
+        st.warning("No data")
+    else:
+        st.header("Generate Reports")
+        st.download_button(
+            "📥 Download full CSV",
+            st.session_state.df.to_csv(index=False),
+            file_name=f"satellite_log_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
+            mime="text/csv"
+        )
+
+        # Simple HTML report
+        report_md = f"""
+# Satellite Telemetry Report
+**Generated:** {datetime.now()}
+
+## Summary
+- Rows: {len(st.session_state.df)}
+- Time range: {st.session_state.df['timestamp'].min() if 'timestamp' in st.session_state.df.columns else 'N/A'}
+
+## Key Stats
+{st.session_state.df.describe().to_markdown()}
+
+## Anomalies (if detected)
+Check the Local Analysis tab.
 """
+        st.download_button("📄 Download Markdown Report", report_md, file_name="report.md")
+
+        st.success("All done! Your Gradio + Streamlit combo is now a full satellite operations suite.")
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# Footer
+st.caption("Built as a companion to your Hugging Face Gradio Satellite Log Analyzer • Powered by Streamlit + gradio_client")