Update src/streamlit_app.py

src/streamlit_app.py

@@ -775,24 +775,29 @@ def upload_page():
             uploaded_file = st.file_uploader(
                 "Choose medical image", 
                 type=['png', 'jpg', 'jpeg', 'dcm'],
-                help="Upload X-ray, CT, MRI, or other medical images (Max 10MB)"
+                help="Upload X-ray, CT, MRI, (Max 10MB)",
+                key="medical_image_upload"
             )
             st.markdown('</div>', unsafe_allow_html=True)
             
-            # Display uploaded image with modern styling
+            # Display uploaded image with modern styling (NO API CALLS)
             if uploaded_file is not None:
                 try:
-                    # Validate file size
+                    # Validate file size only (no API calls)
                     file_size = uploaded_file.size
                     if file_size > 10 * 1024 * 1024:  # 10MB
                         st.error("⚠️ File size too large. Please upload an image smaller than 10MB.")
                     else:
-                        # Display file info
-                        st.info(f"📁 File: {uploaded_file.name} ({file_size/1024:.1f} KB)")
+                        # Display success message and file info
+                        st.success(f"✅ File uploaded successfully: {uploaded_file.name}")
+                        st.info(f"📁 File size: {file_size/1024:.1f} KB")
                         
-                        # Display image
-                        image = Image.open(uploaded_file)
-                        st.image(image, caption="Uploaded Medical Image", use_column_width=True)
+                        # Display image preview (local only, no backend calls)
+                        if uploaded_file.type.startswith('image/'):
+                            image = Image.open(uploaded_file)
+                            st.image(image, caption="Uploaded Medical Image", use_column_width=True)
+                        else:
+                            st.info("📄 DICOM file uploaded successfully")
                         
                         # Reset file pointer for later use
                         uploaded_file.seek(0)
@@ -800,6 +805,8 @@ def upload_page():
                 except Exception as e:
                     st.error(f"❌ Error processing image: {str(e)}")
                     st.info("💡 Please ensure the file is a valid image format (PNG, JPG, JPEG, DCM)")
+            else:
+                st.info("👆 Please upload a medical image to begin analysis")
             
             submit_button = st.form_submit_button("🔍 Generate Report", use_container_width=True)
             
@@ -823,7 +830,7 @@ def generate_report(name, date_of_birth, gender, medical_record_number,
     """Generate report by sending data to backend and displaying the result"""
     try:
         if uploaded_file is not None:
-            with st.spinner("Processing image..."):
+            with st.spinner("🔄 Analyzing medical image..."):
                 # Validate file before sending
                 if uploaded_file.size > 10 * 1024 * 1024:  # 10MB limit
                     st.error("⚠️ File size too large. Please upload an image smaller than 10MB.")
@@ -832,102 +839,83 @@ def generate_report(name, date_of_birth, gender, medical_record_number,
                 # Reset file pointer to beginning
                 uploaded_file.seek(0)
                 
-                # First get AI analysis from backend
-                files = {"file": (uploaded_file.name, uploaded_file, uploaded_file.type)}
+                # Prepare file for upload
+                files = {"file": (uploaded_file.name, uploaded_file.getvalue(), uploaded_file.type)}
                 
                 try:
+                    # Call analyze endpoint
                     analyze_response = requests.post(
-                        f"{FASTAPI_BASE_URL}/analyze/", 
+                        f"{FASTAPI_BASE_URL}/analyze",
                         files=files,
                         timeout=60  # 60 second timeout
                     )
                     
-                    if analyze_response.status_code != 200:
-                        st.error(f"❌ Backend Error (Status {analyze_response.status_code}): {analyze_response.text}")
-                        return
-                    
-                    response_data = analyze_response.json()
-                    
-                    # Check for API errors
-                    if "error" in response_data:
-                        st.error(f"❌ Analysis Error: {response_data['error']}")
-                        return
-                    
-                    findings = response_data.get("findings", "No findings returned.")
-                    status = response_data.get("status", "unknown")
-                    
-                    if status == "error":
-                        st.error(f"❌ Analysis failed: {findings}")
+                    if analyze_response.status_code == 200:
+                        response_data = analyze_response.json()
+                        
+                        # Handle successful response
+                        if response_data.get("success"):
+                            findings = response_data.get("analysis", "Analysis completed")
+                            
+                            # Parse thinking and answer sections
+                            thinking_text = ""
+                            report_text = findings
+                            
+                            if "thinking:" in findings and "answer:" in findings:
+                                parts = findings.split("answer:", 1)
+                                thinking_text = parts[0].replace("thinking:", "").strip()
+                                report_text = parts[1].strip()
+                            
+                            st.success("✅ Analysis completed successfully!")
+                            stream_response(thinking_text, report_text, {
+                                "name": name,
+                                "medical_record_number": medical_record_number,
+                                "referring_physician": referring_physician,
+                                "date_of_study": date_of_study
+                            })
+                            
+                        else:
+                            # Handle failed analysis with fallback
+                            st.warning("⚠️ AI analysis encountered issues, using fallback analysis")
+                            fallback_findings = response_data.get("analysis", "Medical image processed. Professional review recommended.")
+                            stream_response("Fallback analysis used", fallback_findings, {
+                                "name": name,
+                                "medical_record_number": medical_record_number,
+                                "referring_physician": referring_physician,
+                                "date_of_study": date_of_study
+                            })
+                            findings = fallback_findings
+                            
+                    else:
+                        st.error(f"❌ Backend Error (Status {analyze_response.status_code})")
+                        st.error(f"Response: {analyze_response.text}")
                         return
                     
-                    if not findings or findings.strip() == "":
-                        st.warning("⚠️ No findings were generated. Please try again with a different image.")
-                        return
                     
                 except requests.exceptions.Timeout:
-                    st.error("❌ Request timed out. The analysis is taking too long. Please try again.")
+                    st.error("⏱️ Request timed out. The analysis is taking too long. Please try again.")
                     return
                 except requests.exceptions.ConnectionError:
-                    st.error("❌ Cannot connect to backend service. Please ensure the backend is running on http://localhost:8001")
+                    st.error("🔌 Cannot connect to backend service.")
+                    st.error("Please ensure the backend is running at: http://localhost:8001")
+                    st.info("💡 To start the backend, run: `cd backend && python service.py`")
                     return
                 except requests.exceptions.RequestException as e:
                     st.error(f"❌ Request failed: {str(e)}")
                     return
                 
-                # Patient info for the report
-                patient_info = {
-                    "name": name,
-                    "medical_record_number": medical_record_number,
-                    "referring_physician": referring_physician,
-                    "date_of_study": date_of_study
-                }
-                
-                # Show findings and PDF link
-                st.success("✅ Analysis completed successfully!")
-                
-                # Separate thinking process from findings
-                thinking_text = ""
-                report_text = findings
-                
-                # Debug: Show raw findings
-                # st.write("DEBUG - Raw findings:", findings[:200] + "..." if len(findings) > 200 else findings)
-                
-                # Check if findings contains "thinking:" section
-                if "thinking:" in findings.lower():
-                    parts = findings.split("answer:", 1)
-                    if len(parts) == 2:
-                        # Extract thinking part (remove "thinking:" prefix)
-                        thinking_part = parts[0].strip()
-                        if thinking_part.lower().startswith("thinking:"):
-                            thinking_text = thinking_part[9:].strip()  # Remove "thinking:" prefix
-                        else:
-                            thinking_text = thinking_part
-                        
-                        # Extract answer part
-                        report_text = parts[1].strip()
-                        
-                        # Debug: Show extracted parts
-                        # st.write("DEBUG - Thinking text:", thinking_text[:100] + "..." if len(thinking_text) > 100 else thinking_text)
-                        # st.write("DEBUG - Report text:", report_text[:100] + "..." if len(report_text) > 100 else report_text)
-                    else:
-                        # If no "answer:" found, use the whole thinking section
-                        thinking_text = findings
-                        report_text = "Analysis completed."
-                
-                stream_response(thinking_text, report_text, patient_info)
-                
                 # Generate PDF report
-                with st.spinner("Generating PDF report..."):
+                with st.spinner("📄 Generating PDF report..."):
                     try:
                         pdf_response = requests.post(
                             f"{FASTAPI_BASE_URL}/generate-report/",
-                            params={
+                            data={
                                 "patient_name": name,
-                                "medical_record_number": medical_record_number,
+                                "medical_record_number": medical_record_number or "AUTO-GENERATED",
                                 "date_of_birth": date_of_birth,
                                 "gender": gender,
                                 "referring_physician": referring_physician,
-                                "date_of_study": date_of_study,
+                                "study_date": date_of_study,
                                 "findings": findings
                             },
                             timeout=30
@@ -936,7 +924,7 @@ def generate_report(name, date_of_birth, gender, medical_record_number,
                         if pdf_response.status_code == 200:
                             pdf_data = pdf_response.json()
                             if pdf_data.get("success"):
-                                pdf_url = f"{FASTAPI_BASE_URL}/reports/{name}/pdf"
+                                pdf_url = f"{FASTAPI_BASE_URL}/reports/{name.replace(' ', '_')}/pdf" 
                                 st.markdown(f'''
                                 <div style="margin-top: 1rem; padding: 1rem; background: linear-gradient(135deg, #4caf50, #66bb6a); border-radius: 10px;">
                                     <p style="color: white; margin: 0; font-weight: 600;">✅ PDF Report Generated Successfully!</p>
@@ -946,21 +934,21 @@ def generate_report(name, date_of_birth, gender, medical_record_number,
                                 </div>
                                 ''', unsafe_allow_html=True)
                             else:
-                                st.error(f"❌ Failed to generate PDF: {pdf_data.get('error', 'Unknown error')}")
+                                st.error(f"❌ Failed to generate PDF: {pdf_data.get('message', 'Unknown error')}")
                         else:
                             st.error(f"❌ PDF generation failed with status {pdf_response.status_code}")
                             
                     except requests.exceptions.Timeout:
-                        st.error("❌ PDF generation timed out. Please try again.")
+                        st.error("⏱️ PDF generation timed out. Please try again.")
                     except Exception as e:
                         st.error(f"❌ Error generating PDF: {str(e)}")
                 
     except Exception as e:
-        st.error(f"❌ Unexpected error generating report: {str(e)}")
-        st.info("💡 Please check that:")
-        st.info("   • The backend service is running (http://localhost:8001)")
-        st.info("   • The uploaded file is a valid image")
-        st.info("   • Your internet connection is stable")
+        st.error(f"❌ Unexpected error: {str(e)}")
+        st.info("💡 Troubleshooting tips:")
+        st.info("   • Ensure backend service is running on port 8001")
+        st.info("   • Check that the uploaded file is a valid image")
+        st.info("   • Try refreshing the page and uploading again")
 
 def view_reports_page():
     st.markdown('<div class="section-header">📊 View Patient Reports - Search by MRN</div>', unsafe_allow_html=True)