Update app.py

app.py

@@ -1,50 +1,55 @@
 #!/usr/bin/env python3
 """
-Streamlit Brain MRI Tumor Detection App (updated, safe startup + LLM safety)
-- Monkeypatches torch.classes.__path__ before importing streamlit to avoid a Streamlit <-> PyTorch watcher crash.
+Streamlit Brain MRI Tumor Detection App (complete updated version)
+
+Features:
+- Monkeypatches torch.classes.__path__ before importing Streamlit to avoid Streamlit <-> PyTorch watcher crash.
+- Loads a ViT model for image classification (repository: EnDevSols/brainmri-vit-model).
 - Returns probabilistic model output (label + confidence).
-- Adds a visible medical disclaimer.
-- Adds robust error handling around the Groq (Deepseek R1) call and ensures the LLM output contains a safety sentence.
-- Keeps your original UI/CSS with small UX improvements.
+- Adds visible medical disclaimer and safety-first LLM prompting.
+- Robust, defensive Groq (Deepseek R1) integration with detailed error logging and a quick-test button.
+- Developer expander shows helpful debug info (no secrets printed).
 """
 
 import os
 import logging
 import traceback
+import json
+from io import BytesIO
+import base64
 
 # ------------------ Safe startup: import torch first and monkeypatch ------------------
 # This avoids Streamlit's file-watcher triggering PyTorch C++ registry introspection errors.
 try:
-    import torch
-    # Force a benign __path__ so Streamlit's watcher won't attempt unsafe introspection.
+    import torch  # noqa: E402
     try:
-        # If torch.classes exists, ensure __path__ is present and is a harmless list.
+        # Ensure torch.classes.__path__ exists and is a harmless list to prevent Streamlit introspection issues
         if hasattr(torch, "classes"):
-            # Some torch builds may already have __path__; overwrite safely.
             torch.classes.__path__ = []
     except Exception as _e:
-        # If something goes wrong, don't crash the app at module import time.
         logging.warning("Failed to set torch.classes.__path__: %s", _e)
 except Exception as e:
-    # If torch can't be imported at all, we still continue so Streamlit can display an error to the user.
-    # Log it; later we'll surface a friendly message in the UI.
     logging.error("Unable to import torch at startup: %s\n%s", e, traceback.format_exc())
-    torch = None
+    torch = None  # keep variable so rest of app can check availability
 
-# ------------------ Now safe to import Streamlit and other packages ------------------
-import streamlit as st
-from PIL import Image
-from io import BytesIO
-import base64
-from transformers import ViTForImageClassification, ViTImageProcessor
-from groq import Groq
-import numpy as np
-import torch.nn.functional as F
+# ------------------ Now safe to import Streamlit and other libs ------------------
+import streamlit as st  # noqa: E402
+from PIL import Image  # noqa: E402
+import numpy as np  # noqa: E402
+import torch.nn.functional as F  # noqa: E402
+from transformers import ViTForImageClassification, ViTImageProcessor  # noqa: E402
+
+# Groq client (Deepseek R1). Keep import near usage in case environment doesn't have it.
+try:
+    from groq import Groq  # noqa: E402
+except Exception:
+    Groq = None
 
 # ------------------ Logging ------------------
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
 
-# ------------------ Page config + CSS ------------------
+# ------------------ Streamlit page config and CSS ------------------
 st.set_page_config(layout="wide", page_title="Brain MRI Tumor Detection")
 combined_css = """
     .main, .sidebar .sidebar-content { background-color: #1c1c1c; color: #f0f2f6; }
@@ -54,8 +59,8 @@ combined_css = """
     .title {
         font-size: 3rem;
         font-weight: bold;
-        display: flex; 
-        align-items: center; 
+        display: flex;
+        align-items: center;
         justify-content: center;
     }
     .colorful-text {
@@ -78,24 +83,23 @@ combined_css = """
 """
 st.markdown(f"<style>{combined_css}</style>", unsafe_allow_html=True)
 
-# ------------------ App header ------------------
+# ------------------ UI header ------------------
 st.markdown(
     '<div class="title"><span class="colorful-text">Brain MRI</span> <span class="black-white-text">Tumor Detection</span></div>',
-    unsafe_allow_html=True
+    unsafe_allow_html=True,
 )
 st.markdown(
     '<div class="custom-text">Upload an MRI image to detect a brain tumor and receive next steps and recommendations.</div>',
-    unsafe_allow_html=True
+    unsafe_allow_html=True,
 )
 
-# Medical disclaimer (visible)
 st.markdown(
     "<div class='disclaimer'>⚠️ This app is experimental and informational only. It is NOT a medical diagnosis. "
     "If you have health concerns, consult a licensed medical professional. In emergencies call your local emergency number.</div>",
-    unsafe_allow_html=True
+    unsafe_allow_html=True,
 )
 
-# ------------------ Model loading with graceful errors ------------------
+# ------------------ Model loading (graceful) ------------------
 repository_id = "EnDevSols/brainmri-vit-model"
 
 model = None
@@ -103,23 +107,21 @@ feature_extractor = None
 model_load_error = None
 
 try:
-    # Only attempt to load model if torch was imported successfully
     if torch is None:
         raise RuntimeError("Torch is not available in this environment.")
-    # Model loading can be slow; catch errors and show a friendly message later.
+    # Attempt to load the model and feature extractor (this may be slow)
     model = ViTForImageClassification.from_pretrained(repository_id)
     feature_extractor = ViTImageProcessor.from_pretrained(repository_id)
-    logging.info("Model and feature extractor loaded successfully.")
+    logger.info("Model and feature extractor loaded successfully.")
 except Exception as e:
     model_load_error = str(e)
-    logging.error("Failed to load model or feature extractor: %s\n%s", e, traceback.format_exc())
+    logger.exception("Failed to load model or feature extractor: %s", e)
 
-# ------------------ Prediction function (returns label + confidence) ------------------
-def predict(image):
+# ------------------ Prediction function ------------------
+def predict(image: Image.Image):
     """
     Given a PIL image, returns (diagnosis_label, confidence_float).
-    'diagnosis_label' is "Yes" (tumor) or "No" (no tumor).
-    'confidence_float' is between 0 and 1.
+    diagnosis_label is "Yes" or "No". confidence_float is between 0 and 1.
     """
     if model is None or feature_extractor is None:
         raise RuntimeError("Model is not loaded.")
@@ -138,26 +140,28 @@ def predict(image):
     diagnosis = label_map.get(predicted_idx, "Unknown")
     return diagnosis, confidence
 
-# ------------------ Deepseek (Groq) helper ------------------
-def get_assistance_from_deepseek(diagnosis_text):
+# ------------------ Defensive Groq helper with detailed logging ------------------
+def get_assistance_from_deepseek(diagnosis_text: str, max_completion_tokens: int = 512):
     """
-    Calls Groq Deepseek R1 with a safety-first prompt.
-    Returns a string. On error, returns a conservative fallback message.
+    Calls Groq Deepseek R1 with a safety-first prompt. Returns a string message.
+    On failure, returns a safe fallback message and logs detailed info (without exposing secrets).
     """
+    safety_sentence = "This information is informational only — seek evaluation from a licensed medical professional."
+    if Groq is None:
+        logger.error("groq client library not installed or failed to import.")
+        return "Assistance not available: Groq client library not available in this environment."
+
     api_key = os.getenv("API_KEY")
     if not api_key:
-        logging.error("API_KEY environment variable not found for Groq client.")
-        return ("No assistance available because the Deepseek API key is not configured. "
-                "Please set the API_KEY environment variable.")
+        logger.error("API_KEY environment variable not found.")
+        return "No assistance available because the Deepseek API key is not configured. Please set the API_KEY environment variable."
+
     try:
         client = Groq(api_key=api_key)
     except Exception as e:
-        logging.error("Failed to instantiate Groq client: %s\n%s", e, traceback.format_exc())
-        return ("Assistance temporarily unavailable (failed to initialize model client). "
-                "Please try again later or contact support.")
+        logger.exception("Failed to instantiate Groq client: %s", e)
+        return "Assistance temporarily unavailable (failed to initialize model client)."
 
-    # Safer prompt: require the assistant to include a clinician referral sentence
-    safety_sentence = "This information is informational only — seek evaluation from a licensed medical professional."
     prompt = (
         f"You are a cautious, safety-first medical assistant. Given the model-diagnosis below, "
         "provide general, non-prescriptive information a patient could use to understand options. "
@@ -170,20 +174,26 @@ def get_assistance_from_deepseek(diagnosis_text):
 
     messages = [
         {"role": "system", "content": "You are a careful medical assistant always advising a user to consult a clinician."},
-        {"role": "user", "content": prompt}
+        {"role": "user", "content": prompt},
     ]
 
+    # Log non-sensitive metadata
+    try:
+        logger.info("Sending Groq request: model=deepseek-r1-distill-llama-70b, prompt_chars=%d", len(prompt))
+    except Exception:
+        pass
+
     try:
         completion = client.chat.completions.create(
             model="deepseek-r1-distill-llama-70b",
             messages=messages,
             temperature=0.6,
-            max_completion_tokens=1024,
+            max_completion_tokens=max_completion_tokens,
             top_p=0.95,
             stream=False,
             stop=None,
         )
-        # Try different response shapes safely
+        # Extract response robustly
         assistance_text = ""
         try:
             assistance_text = completion.choices[0].message.content
@@ -193,79 +203,167 @@ def get_assistance_from_deepseek(diagnosis_text):
             except Exception:
                 assistance_text = str(completion)
 
-        # Ensure the required safety sentence is present
+        # Ensure safety sentence present
         if safety_sentence not in assistance_text:
             assistance_text = safety_sentence + "\n\n" + assistance_text
-
         return assistance_text
     except Exception as e:
-        logging.error("Deepseek Groq call failed: %s\n%s", e, traceback.format_exc())
-        return ("Assistance is temporarily unavailable due to an error contacting the assistance model. "
-                "Please consult a licensed medical professional for evaluation. If you are experiencing severe or life-threatening symptoms, seek emergency care immediately.")
+        # Detailed logging for debugging 400/other errors
+        logger.exception("Groq API call failed: %s", e)
+        # Attempt to surface HTTP-like details from common exception attributes
+        resp_obj = None
+        for attr in ("response", "http_response", "raw_response", "resp"):
+            resp_obj = getattr(e, attr, None)
+            if resp_obj:
+                break
+
+        if resp_obj:
+            try:
+                status = getattr(resp_obj, "status_code", getattr(resp_obj, "status", "unknown"))
+                body = getattr(resp_obj, "text", getattr(resp_obj, "body", None))
+                # Log a concise summary without printing large bodies
+                logger.error("Groq response object: status=%s body_preview=%s", status, (str(body)[:500] + "...") if body else "None")
+            except Exception:
+                logger.error("Could not extract status/body from response-like object: %s", repr(resp_obj))
+        else:
+            # Log exception repr and attributes for manual inspection
+            logger.error("Groq exception repr: %s", repr(e))
+            logger.error("Groq exception dir: %s", ", ".join(sorted(set(dir(e)))))
 
-# ------------------ Streamlit UI: image upload + inference flow ------------------
+        # Return safe fallback
+        return (
+            "Assistance is temporarily unavailable due to an error contacting the assistance model. "
+            "Please try again later or consult a licensed medical professional. If you have severe or life-threatening symptoms, seek emergency care immediately."
+        )
+
+# ------------------ Small helper: test Groq connectivity (for developer button) ------------------
+def groq_test_ping(max_tokens: int = 8):
+    """
+    Make a minimal test call to the Groq chat endpoint to reproduce/inspect errors.
+    Returns a dict with 'ok' (bool), and 'result' (string or dict).
+    """
+    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 in environment."}
+    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,
+        )
+        # Return a compact representation
+        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:
+        # Attempt to capture useful attributes from the exception
+        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}
+
+# ------------------ Streamlit UI: file uploader and inference flow ------------------
 uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
 
 if uploaded_file is not None:
+    image = None
     try:
         image = Image.open(uploaded_file)
     except Exception as e:
-        st.error(f"Failed to open the uploaded file as an image: {e}")
-        image = None
-
+        st.error(f"Failed to open uploaded file as an image: {e}")
+        logger.exception("Open image error: %s", e)
     if image is not None:
-        # Display resized thumbnail
-        resized_image = image.resize((150, 150))
-        buffered = BytesIO()
-        resized_image.save(buffered, format="JPEG")
-        img_str = base64.b64encode(buffered.getvalue()).decode()
-        st.markdown(
-            f"<div style='text-align: center;'><img src='data:image/jpeg;base64,{img_str}' alt='Uploaded Image' width='300'></div>",
-            unsafe_allow_html=True
-        )
+        # Display a thumbnail
+        try:
+            resized_image = image.resize((150, 150))
+            buffered = BytesIO()
+            resized_image.save(buffered, format="JPEG")
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            st.markdown(
+                f"<div style='text-align: center;'><img src='data:image/jpeg;base64,{img_str}' alt='Uploaded Image' width='300'></div>",
+                unsafe_allow_html=True,
+            )
+        except Exception as e:
+            logger.exception("Failed to create/display thumbnail: %s", e)
 
-        # Check model loaded
+        # Check model availability
         if model_load_error:
-            st.error("The model failed to load at startup. See logs for details.")
+            st.error("The model failed to load at startup. See developer info for details.")
             st.code(model_load_error)
         else:
-            st.write("")
-            st.write("Processing the image...")
+            with st.spinner("Processing the image..."):
+                try:
+                    diagnosis, confidence = predict(image)
+                    st.markdown("### Diagnosis (model prediction):")
+                    st.write(f"**{diagnosis}** (confidence: **{confidence:.2%}**)")
+                    st.markdown("_Model output is probabilistic and not a clinical diagnosis._", unsafe_allow_html=True)
+                except Exception as e:
+                    st.error("Prediction failed: " + str(e))
+                    logger.exception("Prediction error: %s", e)
+                    diagnosis = None
+                    confidence = None
 
-            # Run prediction with try/except
-            try:
-                diagnosis, confidence = predict(image)
-                st.markdown("### Diagnosis (model prediction):")
-                st.write(f"**{diagnosis}** (confidence: **{confidence:.2%}**)")
-                st.markdown("_Model output is probabilistic and not a clinical diagnosis._", unsafe_allow_html=True)
-            except Exception as e:
-                st.error("Prediction failed: " + str(e))
-                logging.error("Prediction error: %s\n%s", e, traceback.format_exc())
-                diagnosis = None
-                confidence = None
-
-            # If we have a diagnosis, call Deepseek for additional guidance (with spinner)
+            # If we have a diagnosis, call Groq for assistance
             if diagnosis is not None:
                 with st.spinner("Fetching additional guidance based on your diagnosis..."):
-                    assistance = get_assistance_from_deepseek(f"Diagnosis: {diagnosis} (confidence {confidence:.2%})")
+                    assistance = get_assistance_from_deepseek(f"Diagnosis: {diagnosis} (confidence {confidence:.2%})", max_completion_tokens=512)
                 st.markdown("### Next Steps and Recommendations:")
-                # Use st.write which keeps newlines and formatting reasonable.
                 st.write(assistance)
 
-# ------------------ If no file uploaded, show sample placeholder / instructions ------------------
+# Footer / instructions when no file uploaded
 if uploaded_file is None:
-    st.markdown("<div class='small-muted'>Upload a brain MRI image (jpg/png) to get a model prediction and informational next steps. </div>", unsafe_allow_html=True)
+    st.markdown("<div class='small-muted'>Upload a brain MRI image (jpg/png) to get a model prediction and informational next steps.</div>", unsafe_allow_html=True)
 
-# ------------------ Helpful debug / info for developers (hidden by default) ------------------
+# ------------------ Developer info / troubleshooting expander ------------------
 with st.expander("Developer info / Troubleshooting"):
-    st.markdown("**Model repository**: " + repository_id)
-    st.markdown("**Torch available**: " + ("Yes" if torch is not None else "No"))
-    st.markdown("**Model loaded**: " + ("Yes" if model is not None else "No"))
+    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"))})
+
     if model_load_error:
+        st.markdown("**Model load error**:")
         st.code(model_load_error)
-    st.markdown("**Environment**:")
-    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"))
-    })
+
     st.markdown("**Notes:**\n- This app is for informational use only. Do not use it as a replacement for professional medical advice.")
+
+    st.markdown("---")
+    st.markdown("### Groq/Deepseek quick test")
+    st.markdown("Use this to reproduce and capture raw error details from the Groq API (no secrets shown).")
+    if st.button("Run Groq test ping"):
+        result = groq_test_ping()
+        if result.get("ok"):
+            st.success("Groq ping successful.")
+            st.text_area("Result (truncated)", str(result.get("result"))[:2000], height=200)
+        else:
+            st.error("Groq ping failed. See details below.")
+            st.json(result.get("result"))
+
+    st.markdown("---")
+    st.markdown("### Debugging tips")
+    st.markdown(
+        "- If you get `400` from the Groq API: check model name, token limits, and `messages` shape.\n"
+        "- Use the Groq test ping to view the API's error body which typically explains the cause.\n"
+        "- Ensure `API_KEY` is set in the environment and has permissions for the model.\n"
+        "- To avoid the Streamlit <-> PyTorch watcher issue you can also run Streamlit with: "
+        "`streamlit run app.py --server.fileWatcherType none` or add `.streamlit/config.toml` with `fileWatcherType = \"none\"`.\n"
+    )
+
+# End of file