Update app.py

app.py

@@ -1,11 +1,14 @@
 #!/usr/bin/env python3
 """
-Streamlit Brain MRI Tumor Detection App (updated):
+Streamlit Brain MRI Tumor Detection App (updated to:
  - load & display the uploaded image(s),
  - pass the image to the ViT model for inference,
  - pass the model inference to the Groq Deepseek R1 LLM to generate an informational medical report,
- - removed Groq "ping" and debugging tips,
- - replaced deprecated use_column_width with use_container_width.
+ - provide robust logging, error handling, and a download for the generated report.
+
+Important:
+ - This app is informational only and not a medical diagnosis.
+ - Set API_KEY in your environment to enable Groq calls.
 """
 
 import os
@@ -23,6 +26,7 @@ try:
         try:
             torch.classes.__path__ = []
         except Exception:
+            # ignore - best-effort
             pass
 except Exception as e:
     torch = None
@@ -118,6 +122,7 @@ def predict_image(image: Image.Image) -> Tuple[str, float]:
     """
     if model is None or feature_extractor is None:
         raise RuntimeError("Model not loaded.")
+    # Preprocess using the feature extractor
     inputs = feature_extractor(images=image, return_tensors="pt")
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model.to(device)
@@ -154,6 +159,8 @@ def generate_medical_report(diagnosis_label: str, confidence: float, image_info:
         logger.exception("Failed to instantiate Groq client: %s", e)
         return "Medical report temporarily unavailable (client init failed)."
 
+    # Construct a concise prompt that includes the model's result and image metadata.
+    # Do NOT include patient identifying data; keep it informational.
     prompt_lines = [
         "You are a careful medical assistant creating an informational medical report for a patient based on an automated image analysis result.",
         f"Model diagnosis: {diagnosis_label}",
@@ -165,8 +172,9 @@ def generate_medical_report(diagnosis_label: str, confidence: float, image_info:
         "Keep language clear and non-technical where possible, and keep it concise (about 3-6 short paragraphs)."
     ]
     if include_image_base64 and image_b64:
+        # Optionally include a tiny thumbnail as base64 (be careful with payload size).
         prompt_lines.append("Note: a small thumbnail was provided (base64), though you should not rely on it for clinical decision-making.")
-        prompt_lines.append(f"Thumbnail (base64, trimmed): {image_b64[:800]}")
+        prompt_lines.append(f"Thumbnail (base64, trimmed): {image_b64[:800]}")  # only include a prefix to avoid huge payloads
 
     prompt = "\n\n".join(prompt_lines)
 
@@ -185,6 +193,7 @@ def generate_medical_report(diagnosis_label: str, confidence: float, image_info:
             stream=False,
             stop=None,
         )
+        # Extract text robustly
         try:
             report_text = completion.choices[0].message.content
         except Exception:
@@ -192,11 +201,13 @@ def generate_medical_report(diagnosis_label: str, confidence: float, image_info:
                 report_text = completion.choices[0].text
             except Exception:
                 report_text = str(completion)
+        # Ensure safety sentence present
         if safety_sentence not in report_text:
             report_text = safety_sentence + "\n\n" + report_text
         return report_text
     except Exception as e:
         logger.exception("Groq call failed: %s", e)
+        # Try to pull useful info from exception if it exists
         resp = None
         for attr in ("response", "http_response", "raw_response", "resp"):
             resp = getattr(e, attr, None)
@@ -225,6 +236,7 @@ def pil_to_base64(img: Image.Image, size: Tuple[int, int] = None) -> str:
 uploaded_file = st.file_uploader("Choose an MRI image (jpg, jpeg, png)", type=["jpg", "jpeg", "png"])
 
 if uploaded_file is not None:
+    # Load image
     try:
         pil_image = Image.open(uploaded_file).convert("RGB")
     except Exception as e:
@@ -233,24 +245,30 @@ if uploaded_file is not None:
         pil_image = None
 
     if pil_image:
+        # Display original and a preprocessed/thumbnail side-by-side
         col1, col2 = st.columns([1, 1])
         with col1:
             st.markdown("**Original image**")
-            st.image(pil_image, use_container_width=True)
+            st.image(pil_image, use_column_width=True)
+        # Create a centered thumbnail / processed view (resize for model preview)
         processed_for_display = ImageOps.contain(pil_image, (512, 512))
         with col2:
             st.markdown("**Processed (for model preview)**")
-            st.image(processed_for_display, use_container_width=True)
+            st.image(processed_for_display, use_column_width=True)
 
+        # Show image metadata
         img_w, img_h = pil_image.size
         st.markdown(f"**Image metadata:** dimensions = {img_w} x {img_h}, mode = {pil_image.mode}")
 
+        # Option to include a small base64 thumbnail in the LLM prompt (default OFF to avoid large payloads)
         include_thumbnail = st.checkbox("Include small thumbnail preview in the generated report prompt (may increase request size)", value=False)
 
+        # Model availability check
         if model_load_error:
             st.error("Model failed to load at startup. See Developer info for details.")
             st.code(model_load_error)
         else:
+            # Run inference
             run_infer = st.button("Run inference & generate report")
             if run_infer:
                 try:
@@ -265,8 +283,11 @@ if uploaded_file is not None:
                     label = None
                     confidence = None
 
+                # If inference ok, call LLM to generate report
                 if label is not None:
+                    # Prepare image_info summary
                     image_info = f"dimensions={img_w}x{img_h}; mode={pil_image.mode}; filename_provided={hasattr(uploaded_file, 'name') and bool(getattr(uploaded_file, 'name', None))}"
+                    # Optionally produce small base64 thumbnail
                     image_b64 = None
                     if include_thumbnail:
                         try:
@@ -280,6 +301,7 @@ if uploaded_file is not None:
                     st.markdown("### Medical Report (informational)")
                     st.write(report_text)
 
+                    # Allow user to download the report as a .txt file
                     try:
                         report_bytes = report_text.encode("utf-8")
                         download_name = f"medical_report_{label}_{int(confidence*100)}pct.txt"
@@ -291,3 +313,76 @@ if uploaded_file is not None:
 # If no file uploaded, show placeholder instructions
 if uploaded_file is None:
     st.markdown("<div class='small-muted'>Upload a brain MRI image (jpg/png) to get a model prediction and an informational medical report.</div>", unsafe_allow_html=True)
+
+# ------------------ Developer troubleshooting expander ------------------
+with st.expander("Developer info / Troubleshooting"):
+    st.markdown(f"**Model repository**: `{repository_id}`")
+    st.markdown(f"**Torch available**: {'Yes' if torch is not None else 'No'}")
+    st.markdown(f"**Model loaded**: {'Yes' if model is not None else 'No'}")
+    st.write({
+        "CUDA available": torch.cuda.is_available() if torch is not None else False,
+        "API_KEY set for Groq": bool(os.getenv("API_KEY")),
+        "Groq installed": Groq is not None
+    })
+    if model_load_error:
+        st.markdown("**Model load error**:")
+        st.code(model_load_error)
+
+    st.markdown("---")
+    st.markdown("### Groq quick test (for debugging API errors)")
+    st.markdown("Click the button to run a very small 'ping' to the Groq chat endpoint. This helps capture raw error info without sending large prompts.")
+    if st.button("Run Groq ping"):
+        # small test call
+        def groq_test_ping(max_tokens: int = 8):
+            if Groq is None:
+                return {"ok": False, "result": "Groq client library not available."}
+            api_key = os.getenv("API_KEY")
+            if not api_key:
+                return {"ok": False, "result": "API_KEY not configured."}
+            try:
+                client = Groq(api_key=api_key)
+                res = client.chat.completions.create(
+                    model="deepseek-r1-distill-llama-70b",
+                    messages=[{"role": "user", "content": "ping"}],
+                    max_completion_tokens=max_tokens,
+                )
+                try:
+                    content = res.choices[0].message.content
+                except Exception:
+                    try:
+                        content = res.choices[0].text
+                    except Exception:
+                        content = str(res)
+                return {"ok": True, "result": content}
+            except Exception as e:
+                info = {"exception_repr": repr(e)}
+                for attr in ("response", "http_response", "raw_response", "resp"):
+                    if hasattr(e, attr):
+                        rval = getattr(e, attr)
+                        try:
+                            info[attr] = {
+                                "status": getattr(rval, "status_code", getattr(rval, "status", "unknown")),
+                                "body_preview": (getattr(rval, "text", getattr(rval, "body", str(rval)))[:1000] + "...") if getattr(rval, "text", None) or getattr(rval, "body", None) else str(rval),
+                            }
+                        except Exception:
+                            info[attr] = str(rval)
+                logger.exception("Groq test ping failed: %s", e)
+                return {"ok": False, "result": info}
+
+        ping_result = groq_test_ping()
+        if ping_result.get("ok"):
+            st.success("Groq ping successful")
+            st.text_area("Result (truncated)", str(ping_result.get("result"))[:2000], height=200)
+        else:
+            st.error("Groq ping failed; see details below")
+            st.json(ping_result.get("result"))
+
+    st.markdown("---")
+    st.markdown("Debugging tips:")
+    st.markdown(
+        "- If Groq returns HTTP 400: check model name, prompt length, and messages shape.\n"
+        "- Use the Groq ping to inspect raw error details.\n"
+        "- Ensure `API_KEY` is set & has permissions for the requested model.\n"
+        "- To avoid the Streamlit <-> PyTorch watcher issue you can also run Streamlit with: "
+        "`streamlit run app.py --server.fileWatcherType none` or set `.streamlit/config.toml`."
+    )