Update app.py

app.py

@@ -1,14 +1,11 @@
 #!/usr/bin/env python3
 """
-Streamlit Brain MRI Tumor Detection App (updated to:
+Streamlit Brain MRI Tumor Detection App (updated):
  - 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,
- - 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.
+ - removed Groq "ping" and debugging tips,
+ - replaced deprecated use_column_width with use_container_width.
 """
 
 import os
@@ -26,7 +23,6 @@ try:
         try:
             torch.classes.__path__ = []
         except Exception:
-            # ignore - best-effort
             pass
 except Exception as e:
     torch = None
@@ -122,7 +118,6 @@ 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)
@@ -159,8 +154,6 @@ 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}",
@@ -172,9 +165,8 @@ 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]}")  # only include a prefix to avoid huge payloads
+        prompt_lines.append(f"Thumbnail (base64, trimmed): {image_b64[:800]}")
 
     prompt = "\n\n".join(prompt_lines)
 
@@ -193,7 +185,6 @@ 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:
@@ -201,13 +192,11 @@ 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)
@@ -236,7 +225,6 @@ 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:
@@ -245,30 +233,24 @@ 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_column_width=True)
-        # Create a centered thumbnail / processed view (resize for model preview)
+            st.image(pil_image, use_container_width=True)
         processed_for_display = ImageOps.contain(pil_image, (512, 512))
         with col2:
             st.markdown("**Processed (for model preview)**")
-            st.image(processed_for_display, use_column_width=True)
+            st.image(processed_for_display, use_container_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:
@@ -283,11 +265,8 @@ 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:
@@ -301,7 +280,6 @@ 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"
@@ -313,76 +291,3 @@ 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`."
-    )