Upload 3 files

Dockerfile

@@ -1,33 +1,28 @@
-# ---------- Public HF Space: Streamlit frontend (DiagStudio AI) ----------
+# Streamlit frontend (TR/EN) — containerized
 FROM python:3.11-slim
 
-# System deps
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    STREAMLIT_SERVER_HEADLESS=true \
+    STREAMLIT_BROWSER_GATHER_USAGE_STATS=false \
+    PORT=7860
+
+# (Optional) useful utils
 RUN apt-get update && apt-get install -y --no-install-recommends \
     ca-certificates curl && \
     rm -rf /var/lib/apt/lists/*
 
-# Prevent Python from writing .pyc; flush stdout
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1
-
-# Streamlit needs a writable HOME; disable usage stats; headless mode
-ENV HOME=/tmp \
-    STREAMLIT_BROWSER_GATHER_USAGE_STATS=false \
-    STREAMLIT_SERVER_HEADLESS=true
-
-# Workdir
 WORKDIR /app
 
 # Install deps first (better layer caching)
 COPY requirements.txt /app/requirements.txt
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
 
-# Copy app
+# Copy app last
 COPY app.py /app/app.py
 
-# Spaces Docker expects the app to listen on 7860
+# If you mount envs in HF Space, they’ll be visible at runtime (no bake-in here)
 EXPOSE 7860
 
-# Bind to 0.0.0.0 and honor $PORT if provided by platform
-# Using sh -c form to expand ${PORT}; recommended for passing env to CMD
-CMD ["sh", "-c", "streamlit run app.py --server.address=0.0.0.0 --server.port=${PORT:-7860}"]
+# Streamlit CLI with explicit address/port (headless)  :contentReference[oaicite:3]{index=3}
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.port=7860"]

app.py

@@ -1,14 +1,5 @@
-# app.py — DiagStudio AI (Streamlit frontend)
-# Pairs with the FastAPI backend (composite image + JSON mode).
-# Backend URL via one of:
-#   CARDIAG_AI_API  |  AI_LIGHTBOX_API  |  LUXFIT_API
-# Optional bearer token passthrough:
-#   CARDIAG_AI_TOKEN | AI_LIGHTBOX_TOKEN | LUXFIT_TOKEN
-#
-# Run:
-#   CARDIAG_AI_API="https://<your-private-backend>" streamlit run app.py --server.port 7860
-
-import os, json, time, hashlib, requests, io, base64
+# app.py — Streamlit Frontend for Diag Studio AI
+import os, json, time, io, requests, traceback
 import streamlit as st
 
 # ---- container-safe defaults to avoid '/.streamlit' permission errors
@@ -24,6 +15,8 @@ try:
     st._config.set_option("theme.secondaryBackgroundColor", "#171a1f")
     st._config.set_option("theme.textColor", "#e6e8ea")
 except Exception:
+    # Themes usually set via config.toml, but programmatic options apply at runtime.
+    # See Streamlit theming docs.  # docs: https://docs.streamlit.io/develop/concepts/configuration/theming
     pass
 
 # ================= Env & API =================
@@ -37,215 +30,180 @@ API_BASE = (
 HF_TOKEN = _env("CARDIAG_AI_TOKEN") or _env("AI_LIGHTBOX_TOKEN") or _env("LUXFIT_TOKEN")
 HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
 
-# ================= Page =================
-st.set_page_config(page_title="DiagStudio AI", layout="wide")
-st.title("DiagStudio AI")
-st.caption("Upload a short engine recording and get a clear diagnosis with visuals and next steps.")
-
-# ================= Helpers =================
-@st.cache_data(show_spinner=False, ttl=20)
-def _health(url: str, headers: dict) -> bool:
-    try:
-        r = requests.get(f"{url}/health", headers=headers, timeout=10)
-        return r.status_code == 200
-    except Exception:
-        return False
-
-def _nice_conf(x) -> float:
-    try:
-        return min(max(float(x), 0.0), 1.0)
-    except Exception:
-        return 0.0
-
-def _post_analyze(audio_file, rpm_file, sr_target, n_fft, hop, env_band, run_llm, notes):
-    files = {}
-    if audio_file is not None:
-        files["audio"] = (audio_file.name, audio_file.getvalue(), audio_file.type or "application/octet-stream")
-    if rpm_file is not None:
-        files["rpm_csv"] = (rpm_file.name, rpm_file.getvalue(), "text/csv")
-    data = {
-        "sr_target": str(sr_target),
-        "n_fft": str(n_fft),
-        "hop": str(hop),
-        "env_band": env_band,
-        "run_llm": "true" if run_llm else "false",
-        "extra_text": notes or "",
-        "nonce": str(time.time())  # cache-bypass hint (backend already sets no-store)
+# ================= i18n =================
+L = {
+    "en": {
+        "title": "Diag Studio AI — Engine Sound Diagnosis",
+        "about": "Upload an engine sound (mp3/wav/ogg) or paste an audio URL. The backend runs fal.ai audio-understanding with detailed analysis, then summarizes with GPT-4o.",
+        "backend_url": "Backend URL",
+        "lang": "Language",
+        "upload": "Upload audio file",
+        "or": "or",
+        "paste_url": "Paste audio URL (optional)",
+        "adv": "Advanced",
+        "prompt": "Override prompt (optional)",
+        "detailed": "Detailed analysis",
+        "use_data_uri": "Send as data:URI (safer for private backends)",
+        "model": "Commentary model (OpenAI)",
+        "analyze": "Analyze",
+        "reset": "Reset",
+        "result": "Result",
+        "commentary": "Commentary (driver-friendly)",
+        "json": "Parsed JSON",
+        "backend_artifacts": "Backend artifacts",
+        "download_summary": "Download summary.txt",
+        "download_parsed": "Download parsed.json",
+        "download_raw": "Download raw.txt",
+        "no_backend": "Enter a backend URL (e.g., http://127.0.0.1:7860)",
+        "health_ok": "Backend is reachable.",
+        "health_fail": "Backend not reachable.",
+        "upload_hint": "Max ~200 MB per Streamlit docs; use mp3/wav/ogg.",
+        "footer": "Tip: You can also paste a public audio URL if you don’t want to upload the file."
+    },
+    "tr": {
+        "title": "Diag Studio AI — Motor Sesi Teşhis",
+        "about": "Motor sesini (mp3/wav/ogg) yükleyin veya bir ses URL’si verin. Backend fal.ai audio-understanding’ı ayrıntılı analizle çalıştırır, ardından GPT-4o ile özetler.",
+        "backend_url": "Backend URL",
+        "lang": "Dil",
+        "upload": "Ses dosyası yükle",
+        "or": "veya",
+        "paste_url": "Ses URL’si (opsiyonel)",
+        "adv": "Gelişmiş",
+        "prompt": "Prompt geçersiz kıl (opsiyonel)",
+        "detailed": "Ayrıntılı analiz",
+        "use_data_uri": "data:URI olarak gönder (özel backend için güvenli)",
+        "model": "Yorum modeli (OpenAI)",
+        "analyze": "Analiz Et",
+        "reset": "Sıfırla",
+        "result": "Sonuç",
+        "commentary": "Yorum (sürücü dostu)",
+        "json": "Ayrıştırılmış JSON",
+        "backend_artifacts": "Backend çıktıları",
+        "download_summary": "summary.txt indir",
+        "download_parsed": "parsed.json indir",
+        "download_raw": "raw.txt indir",
+        "no_backend": "Bir backend URL girin (örn: http://127.0.0.1:7860)",
+        "health_ok": "Backend erişilebilir.",
+        "health_fail": "Backend’e erişilemedi.",
+        "upload_hint": "Streamlit varsayılan üst sınır ~200 MB; mp3/wav/ogg kullanın.",
+        "footer": "İpucu: Dosya yüklemek istemezseniz herkese açık bir ses URL’si de girebilirsiniz."
     }
-    r = requests.post(f"{API_BASE}/analyze", headers=HEADERS, files=files, data=data, timeout=240)
-    r.raise_for_status()
-    return r.json()
-
-def _post_analyze_zip(audio_file, rpm_file, sr_target, n_fft, hop, env_band, run_llm, notes) -> bytes:
-    files = {}
-    if audio_file is not None:
-        files["audio"] = (audio_file.name, audio_file.getvalue(), audio_file.type or "application/octet-stream")
-    if rpm_file is not None:
-        files["rpm_csv"] = (rpm_file.name, rpm_file.getvalue(), "text/csv")
-    data = {
-        "sr_target": str(sr_target),
-        "n_fft": str(n_fft),
-        "hop": str(hop),
-        "env_band": env_band,
-        "run_llm": "true" if run_llm else "false",
-        "extra_text": notes or "",
-        "nonce": str(time.time())
-    }
-    r = requests.post(f"{API_BASE}/analyze_zip", headers=HEADERS, files=files, data=data, timeout=300, stream=True)
-    r.raise_for_status()
-    return r.content
-
-# ================= Sidebar =================
-with st.sidebar:
-    st.header("Upload")
-    audio_up = st.file_uploader("Engine recording (WAV/MP3/M4A)", type=["wav", "mp3", "m4a"])
-    rpm_up = st.file_uploader("Optional RPM CSV (time_sec,rpm)", type=["csv"])
-
-    st.header("Options")
-    run_llm = st.toggle("Explain with AI", value=True, help="Get a readable diagnosis and next steps.")
-    user_notes = st.text_area("Context (optional)", placeholder="Vehicle, engine type, driving condition, symptoms…")
-
-    with st.expander("Advanced (defaults are fine)"):
-        sr_target = st.select_slider("Sample rate (Hz)", options=[16000, 22050, 32000, 44100, 48000], value=22050)
-        n_fft = st.select_slider("Analysis window (n_fft)", options=[1024, 2048, 4096], value=2048)
-        hop = st.select_slider("Hop length", options=[128, 256, 512, 1024], value=512)
-        env_band = st.text_input("Impact band (Hz low,high or 'auto')", value="auto")
-
-    # Allow manual URL override if env not set
-    if not API_BASE:
-        API_BASE = st.text_input("Backend URL", value="", placeholder="https://<your-private-backend>").strip().rstrip("/")
-    ok = _health(API_BASE, HEADERS) if API_BASE else False
-    if not API_BASE:
-        st.error("Backend URL missing. Set CARDIAG_AI_API env or enter it above.")
-    elif not ok:
-        st.warning("Backend not reachable. Check URL or token.")
-    analyze_btn = st.button("Analyze now", type="primary", disabled=(audio_up is None or not ok))
-
-# ================= Reset state on file change =================
-if "last_audio_id" not in st.session_state:
-    st.session_state["last_audio_id"] = None
-if audio_up is not None:
-    _aid = hashlib.sha256(audio_up.getvalue()).hexdigest()[:12]
-    if st.session_state["last_audio_id"] != _aid:
-        st.session_state["last_audio_id"] = _aid
-        st.session_state.pop("last_result", None)
-
-status_ph = st.empty()
-
-# ================= Action =================
-if analyze_btn and audio_up is not None:
-    status_ph.info("Analyzing…")
-    t0 = time.time()
-    try:
-        data = _post_analyze(audio_up, rpm_up, sr_target, n_fft, hop, env_band, run_llm, user_notes)
-        st.session_state["last_result"] = data
-        status_ph.success(f"Done in {time.time()-t0:.1f}s")
-    except requests.HTTPError as e:
-        status_ph.error(f"Backend error: {e.response.status_code} — {e.response.text[:300]}")
-    except Exception as e:
-        status_ph.error(f"Request failed: {e}")
-
-res = st.session_state.get("last_result")
-
-# ================= Result =================
+}
+
+# ================= Session State =================
+if "lang" not in st.session_state:
+    st.session_state.lang = "tr"
+if "last_response" not in st.session_state:
+    st.session_state.last_response = None
+
+# ================= UI =================
+col1, col2 = st.columns([0.65, 0.35])
+with col1:
+    st.title(L[st.session_state.lang]["title"])
+with col2:
+    st.session_state.lang = st.selectbox(
+        L[st.session_state.lang]["lang"],
+        ["tr", "en"],
+        index=(0 if st.session_state.lang == "tr" else 1),
+        key="lang_selector",
+    )
+
+t = L[st.session_state.lang]
+st.caption(t["about"])
+
+backend_default = API_BASE or "http://127.0.0.1:7860"
+api_base = st.text_input(t["backend_url"], value=backend_default)
+
+# Health check
+health_col, spacer = st.columns([0.28, 0.72])
+with health_col:
+    if st.button("🔄 Health"):
+        try:
+            r = requests.get(f"{api_base}/health", headers=HEADERS, timeout=10)
+            if r.ok:
+                st.success(t["health_ok"])
+            else:
+                st.error(t["health_fail"])
+        except Exception:
+            st.error(t["health_fail"])
+
+st.markdown("---")
+
+# Upload or URL input
+st.write(t["upload_hint"])
+file = st.file_uploader(t["upload"], type=["mp3", "wav", "ogg"])  # accepts file-like objects; returns UploadedFile. Docs show in-memory behavior.  # 
+        files = {"file": (_file.name, _file, _file.type or "application/octet-stream")}
+    elif _audio_url.strip():
+        data["audio_url"] = _audio_url.strip()
+
+    resp = requests.post(url, headers=_headers, data=data, files=files, timeout=180)
+    resp.raise_for_status()
+    return resp.json()
+
+if go:
+    if not api_base:
+        st.error(t["no_backend"])
+    elif not file and not audio_url.strip():
+        st.error(t["upload"])
+    else:
+        with st.spinner("Analyzing..."):
+            try:
+                res = post_analyze(api_base, HEADERS, file, audio_url)
+                st.session_state.last_response = res
+            except Exception as e:
+                st.error(f"Request failed: {e}")
+                st.stop()
+
+# ============== Results ==============
+res = st.session_state.last_response
 if res:
-    st.subheader("Result")
-
-    params = res.get("params", {})
-    llm = res.get("llm_report") or {}
-    imgs = res.get("images", {}) if isinstance(res.get("images", {}), dict) else {}
+    st.subheader(t["result"])
+
+    # Commentary
+    comm = res.get("commentary") or ""
+    if comm:
+        st.markdown(f"**{t['commentary']}**")
+        st.write(comm)
+
+    # JSON pretty
+    parsed = res.get("fal_parsed")
+    if parsed:
+        st.markdown(f"**{t['json']}**")
+        st.json(parsed)  # renders a collapsible JSON tree
+
+    # Backend artifacts — download via Streamlit
+    st.markdown(f"**{t['backend_artifacts']}**")
+    dls = res.get("downloads") or {}
+    col_a, col_b, col_c = st.columns(3)
+
+    def fetch_bytes(url: str) -> bytes:
+        r = requests.get(url if url.startswith("http") else f"{api_base}{url}", headers=HEADERS, timeout=60)
+        r.raise_for_status()
+        return r.content
+
+    # summary
+    if dls.get("summary_txt"):
+        try:
+            data = fetch_bytes(dls["summary_txt"])
+            col_a.download_button(label=t["download_summary"], data=data, file_name="summary.txt")
+        except Exception as e:
+            col_a.error("summary.txt ✖")
 
-    st.caption(f"AI model: **{params.get('vision_model','gpt-4o')}**")
-    if params.get("audio_id"):
-        st.caption(f"Audio ID: **{params['audio_id']}**")
-    if params.get("features"):
-        feat = params["features"]
+    # parsed
+    if dls.get("fal_parsed_json"):
         try:
-            st.caption(
-                f"Features — rms: {feat.get('rms'):.4f}, zcr: {feat.get('zcr'):.4f}, "
-                f"centroid: {feat.get('centroid'):.1f} Hz, rolloff: {feat.get('rolloff'):.1f} Hz, "
-                f"flux: {feat.get('flux'):.2f}"
-            )
-        except Exception:
-            st.caption(f"Features — {feat}")
-
-    if isinstance(llm, dict) and llm.get("meta"):
-        meta = llm["meta"]
-        st.caption(f"Vision meta — seen_images: {meta.get('seen_images')}, views: {meta.get('views')}")
-
-    col1, col2 = st.columns([1, 1])
-    diag_list = llm.get("diagnosis", [])
-    notes = llm.get("notes", "")
-    next_tests = llm.get("next_tests", "")
-
-    with col1:
-        st.markdown("**Likely issues**")
-        if isinstance(diag_list, list) and len(diag_list) > 0:
-            for item in diag_list:
-                label = str(item.get("label", "Issue"))
-                conf = _nice_conf(item.get("likelihood", 0))
-                st.text(label)
-                st.progress(conf)
-                if item.get("evidence"):
-                    st.caption(item["evidence"])
-        else:
-            st.info("No specific faults detected with high confidence.")
-
-    with col2:
-        if notes:
-            st.markdown("**Mechanic-friendly notes**")
-            st.write(notes)
-        if next_tests:
-            st.markdown("**Suggested next checks**")
-            st.write(next_tests)
-
-    st.subheader("Visual checks")
-    tabs = st.tabs([
-        "Composite",
-        "Energy over time",
-        "Perceptual view",
-        "Impact pattern",
-        "Signal envelope",
-        "Order view",
-    ])
-
-    with tabs[0]:
-        if imgs.get("composite"): st.image(imgs["composite"], caption="Composite diagnostic figure")
-        else: st.caption("Composite image is not available.")
-
-    with tabs[1]:
-        if imgs.get("stft"): st.image(imgs["stft"], caption="Energy distribution across time.")
-        else: st.caption("Shown in composite.")
-
-    with tabs[2]:
-        if imgs.get("mel"): st.image(imgs["mel"], caption="Perceptually-weighted overview.")
-        else: st.caption("Shown in composite.")
-
-    with tabs[3]:
-        if imgs.get("envelope_spectrum"): st.image(imgs["envelope_spectrum"], caption="Repetitive impact signature.")
-        else: st.caption("Shown in composite.")
-
-    with tabs[4]:
-        if imgs.get("envelope_trace"): st.image(imgs["envelope_trace"], caption="Overall intensity trace.")
-        else: st.caption("Shown in composite.")
-
-    with tabs[5]:
-        if imgs.get("order_map"): st.image(imgs["order_map"], caption="Patterns that track engine speed.")
-        else: st.caption("Order view requires an RPM CSV (time_sec,rpm).")
-
-    st.divider()
-    st.subheader("Download")
-    st.caption("Get all visuals and the diagnosis as a single ZIP.")
-    if st.button("Prepare ZIP"):
+            data = fetch_bytes(dls["fal_parsed_json"])
+            col_b.download_button(label=t["download_parsed"], data=data, file_name="parsed.json", mime="application/json")
+        except Exception as e:
+            col_b.error("parsed.json ✖")
+
+    # raw
+    if dls.get("fal_raw_txt"):
         try:
-            zbytes = _post_analyze_zip(audio_up, rpm_up, sr_target, n_fft, hop, env_band, run_llm, user_notes)
-            st.download_button(
-                "Download results (ZIP)",
-                data=zbytes,
-                file_name="diagstudio_results.zip",
-                mime="application/zip"
-            )
+            data = fetch_bytes(dls["fal_raw_txt"])
+            col_c.download_button(label=t["download_raw"], data=data, file_name="raw.txt")
         except Exception as e:
-            st.error(f"ZIP build failed: {e}")
-else:
-    st.info("Upload an engine recording, optionally add an RPM CSV, then click Analyze.")
+            col_c.error("raw.txt ✖")
+
+# ===== Footer =====
+st.caption("© 2025 Diag Studio AI — Streamlit frontend")

requirements.txt

@@ -1,2 +1,2 @@
-streamlit>=1.36
-requests>=2.32
+streamlit==1.40.0
+requests>=2.31.0