updated the code ✅✅ will see tomorrow

mediSync/app.py

@@ -399,9 +399,11 @@ class MediSyncApp:
 
 
 def create_interface():
-    """Create and launch the Gradio interface with all fixes."""
+    """Create and launch the Gradio interface with all fixes implemented."""
+
     app = MediSyncApp()
 
+    # Example medical report for demo
     example_report = """
     CHEST X-RAY EXAMINATION
     
@@ -420,74 +422,52 @@ def create_interface():
     RECOMMENDATIONS: Follow-up chest CT to further characterize the nodular opacity in the right lower lobe.
     """
 
-    # Sample image handling with local fallback
+    # Get sample image path with robust error handling
     sample_image_path = None
     try:
         sample_images_dir = Path(__file__).parent.parent / "data" / "sample"
         os.makedirs(sample_images_dir, exist_ok=True)
         
-        # First check for existing local images
+        # Check for existing images first
         sample_images = list(sample_images_dir.glob("*.png")) + list(sample_images_dir.glob("*.jpg"))
         
         if not sample_images:
-            # Use local fallback if no images exist
-            local_fallback = Path(__file__).parent.parent / "static" / "fallback_xray.jpg"
-            if local_fallback.exists():
-                sample_image_path = str(local_fallback)
-                logger.info("Using local fallback sample image")
-            else:
-                logger.warning("No local fallback image found")
+            # Download fallback sample image if none exist
+            fallback_url = "https://raw.githubusercontent.com/ieee8023/covid-chestxray-dataset/master/images/1-s2.0-S0929664620300449-gr2_lrg-a.jpg"
+            sample_path = sample_images_dir / "sample_xray.jpg"
+            
+            try:
+                response = requests.get(fallback_url, timeout=10)
+                if response.status_code == 200:
+                    with open(sample_path, 'wb') as f:
+                        f.write(response.content)
+                    sample_image_path = str(sample_path)
+                    logging.info("Successfully downloaded fallback sample image")
+                else:
+                    logging.warning(f"Failed to download sample image. Status code: {response.status_code}")
+            except Exception as download_error:
+                logging.warning(f"Could not download sample image: {str(download_error)}")
         else:
             sample_image_path = str(sample_images[0])
     except Exception as e:
-        logger.error(f"Error handling sample images: {str(e)}")
-
-    custom_css = """
-    .alert-box {
-        padding: 15px;
-        margin: 10px 0;
-        border-radius: 5px;
-        font-family: sans-serif;
-    }
-    .alert-error {
-        background-color: #ffebee;
-        color: #b71c1c;
-        border-left: 5px solid #b71c1c;
-    }
-    .alert-success {
-        background-color: #e8f5e9;
-        color: #1b5e20;
-        border-left: 5px solid #1b5e20;
-    }
-    """
+        logging.error(f"Error setting up sample images: {str(e)}")
 
+    # Define interface with robust parameter handling
     with gr.Blocks(
-        title="MediSync: Multi-Modal Medical Analysis System",
-        theme=gr.themes.Soft(),
-        css=custom_css
+        title="MediSync: Multi-Modal Medical Analysis System", 
+        theme=gr.themes.Soft()
     ) as interface:
-        
-        # Session state to track if consultation was properly recorded
-        session_state = gr.State({
-            'recorded': False,
-            'appointment_id': ''
-        })
-
-        # Initialize appointment ID from URL
-        def get_appointment_id():
-            try:
-                from gradio.context import Context
-                if hasattr(Context, 'request') and hasattr(Context.request, 'query_params'):
-                    appointment_id = Context.request.query_params.get("appointment_id", "")
-                    if appointment_id:
-                        return {'recorded': False, 'appointment_id': appointment_id}
-            except Exception as e:
-                logger.warning(f"Could not get URL parameters: {str(e)}")
-            return {'recorded': False, 'appointment_id': ''}
+        # Get appointment ID from URL parameters
+        try:
+            from gradio.context import Context
+            appointment_id_value = Context.request.query_params.get("appointment_id", "") if hasattr(Context, 'request') else ""
+        except Exception as e:
+            logging.warning(f"Could not get URL parameters: {str(e)}")
+            appointment_id_value = ""
 
-        interface.load(
-            fn=get_appointment_id,
-            outputs=[session_state]
+        appointment_id = gr.Textbox(
+            visible=False,
+            value=appointment_id_value
         )
 
         gr.Markdown("""
@@ -495,94 +475,195 @@ def create_interface():
         
         This AI-powered healthcare solution combines X-ray image analysis with patient report text processing 
         to provide comprehensive medical insights.
+        
+        ## How to Use
+        1. Upload a chest X-ray image
+        2. Enter the corresponding medical report text
+        3. Choose the analysis type: image-only, text-only, or multimodal (combined)
+        4. Click "End Consultation" when finished to complete your appointment
         """)
 
-        # ... (keep all your existing tabs and components)
+        with gr.Tab("Multimodal Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    multi_img_input = gr.Image(label="Upload X-ray Image", type="pil")
+                    multi_img_enhance = gr.Button("Enhance Image")
+
+                    multi_text_input = gr.Textbox(
+                        label="Enter Medical Report Text",
+                        placeholder="Enter the radiologist's report text here...",
+                        lines=10,
+                        value=example_report if not sample_image_path else None,
+                    )
+
+                    multi_analyze_btn = gr.Button(
+                        "Analyze Image & Text", variant="primary"
+                    )
+
+                with gr.Column():
+                    multi_results = gr.HTML(label="Analysis Results")
+                    multi_plot = gr.HTML(label="Visualization")
+
+            if sample_image_path:
+                gr.Examples(
+                    examples=[[sample_image_path, example_report]],
+                    inputs=[multi_img_input, multi_text_input],
+                    label="Example X-ray and Report",
+                )
 
+        with gr.Tab("Image Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    img_input = gr.Image(label="Upload X-ray Image", type="pil")
+                    img_enhance = gr.Button("Enhance Image")
+                    img_analyze_btn = gr.Button("Analyze Image", variant="primary")
+
+                with gr.Column():
+                    img_output = gr.Image(label="Processed Image")
+                    img_results = gr.HTML(label="Analysis Results")
+                    img_plot = gr.HTML(label="Visualization")
+
+            if sample_image_path:
+                gr.Examples(
+                    examples=[[sample_image_path]],
+                    inputs=[img_input],
+                    label="Example X-ray Image",
+                )
+
+        with gr.Tab("Text Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Enter Medical Report Text",
+                        placeholder="Enter the radiologist's report text here...",
+                        lines=10,
+                        value=example_report,
+                    )
+                    text_analyze_btn = gr.Button("Analyze Text", variant="primary")
+
+                with gr.Column():
+                    text_output = gr.Textbox(label="Processed Text")
+                    text_results = gr.HTML(label="Analysis Results")
+                    text_plot = gr.HTML(label="Entity Visualization")
+
+            gr.Examples(
+                examples=[[example_report]],
+                inputs=[text_input],
+                label="Example Medical Report",
+            )
+
+        with gr.Tab("About"):
+            gr.Markdown("""
+            ## About MediSync
+            
+            MediSync is an AI-powered healthcare solution that uses multi-modal analysis to provide comprehensive insights from medical images and reports.
+            
+            ### Key Features
+            
+            - **X-ray Image Analysis**: Detects abnormalities in chest X-rays using pre-trained vision models
+            - **Medical Report Processing**: Extracts key information from patient reports using NLP models
+            - **Multi-modal Integration**: Combines insights from both image and text data for more accurate analysis
+            
+            ### Models Used
+            
+            - **X-ray Analysis**: facebook/deit-base-patch16-224-medical-cxr
+            - **Medical Text Analysis**: medicalai/ClinicalBERT
+            
+            ### Important Disclaimer
+            
+            This tool is for educational and research purposes only. It is not intended to provide medical advice or replace professional healthcare. Always consult with qualified healthcare providers for medical decisions.
+            """)
+
+        # Consultation completion section
         with gr.Row():
             with gr.Column():
-                end_consultation_btn = gr.Button("End Consultation", variant="stop", size="lg")
+                end_consultation_btn = gr.Button(
+                    "End Consultation", 
+                    variant="stop",
+                    size="lg"
+                )
                 completion_status = gr.HTML()
 
-        def complete_consultation(session_state):
-            """Handle consultation completion with proper session recording."""
-            if not session_state['appointment_id']:
-                error_html = """
-                <div class="alert-box alert-error">
-                    <strong>No Appointment ID Found</strong>
-                    <p>Please contact support to ensure your session is recorded.</p>
-                </div>
-                """
-                logger.error("Completion attempted without appointment ID")
-                return {'recorded': False, 'appointment_id': ''}, error_html
+        # Set up event handlers
+        multi_img_enhance.click(
+            app.enhance_image, inputs=multi_img_input, outputs=multi_img_input
+        )
+        multi_analyze_btn.click(
+            app.analyze_multimodal,
+            inputs=[multi_img_input, multi_text_input],
+            outputs=[multi_results, multi_plot],
+        )
+
+        img_enhance.click(app.enhance_image, inputs=img_input, outputs=img_output)
+        img_analyze_btn.click(
+            app.analyze_image,
+            inputs=img_input,
+            outputs=[img_output, img_results, img_plot],
+        )
+
+        text_analyze_btn.click(
+            app.analyze_text,
+            inputs=text_input,
+            outputs=[text_output, text_results, text_plot],
+        )
+
+        def complete_consultation(appointment_id):
+            """Handle consultation completion."""
+            if not appointment_id:
+                return "<div class='alert alert-error'>No appointment ID found. Please contact support.</div>"
             
             try:
-                # First verify if already recorded
-                if session_state['recorded']:
-                    success_html = """
-                    <div class="alert-box alert-success">
-                        <strong>Consultation Already Completed</strong>
-                        <p>You will be redirected shortly.</p>
-                        <script>
-                            setTimeout(() => window.location.href = "http://127.0.0.1:600/doctors", 1000);
-                        </script>
-                    </div>
-                    """
-                    return session_state, success_html
-
-                # Call your Flask endpoint to record completion
+                # Replace with your actual Flask app URL
+                flask_app_url = "http://127.0.0.1:600/complete_consultation"
+                
                 response = requests.post(
-                    "http://127.0.0.1:600/complete_consultation",
-                    json={"appointment_id": session_state['appointment_id']},
+                    flask_app_url,
+                    json={"appointment_id": appointment_id},
                     timeout=10
                 )
-
-                if response.ok:
-                    success_html = """
-                    <div class="alert-box alert-success">
-                        <strong>Consultation Successfully Recorded</strong>
-                        <p>Your session has been properly recorded.</p>
-                        <p>You will be redirected shortly.</p>
+                
+                if response.status_code == 200:
+                    return """
+                    <div class='alert alert-success'>
+                        Consultation completed successfully. Redirecting...
                         <script>
-                            setTimeout(() => window.location.href = "http://127.0.0.1:600/doctors", 2000);
+                            setTimeout(function() {
+                                window.location.href = "http://127.0.0.1:600/doctors";
+                            }, 2000);
                         </script>
                     </div>
                     """
-                    logger.info(f"Successfully recorded appointment {session_state['appointment_id']}")
-                    return {'recorded': True, 'appointment_id': session_state['appointment_id']}, success_html
-                
-                error_msg = f"Server error: {response.status_code}"
-                if response.text:
-                    error_msg += f" - {response.text[:200]}"
-                logger.error(error_msg)
-                return session_state, f"""
-                <div class="alert-box alert-error">
-                    <strong>Recording Failed</strong>
-                    <p>{error_msg}</p>
-                    <p>Please try again or contact support.</p>
-                </div>
-                """
+                else:
+                    return f"""
+                    <div class='alert alert-error'>
+                        Error completing appointment (Status: {response.status_code}). 
+                        Please contact support.
+                    </div>
+                    """
+                    
             except Exception as e:
-                logger.error(f"Completion error: {str(e)}")
-                return session_state, f"""
-                <div class="alert-box alert-error">
-                    <strong>Connection Error</strong>
-                    <p>{str(e)}</p>
-                    <p>Please check your connection and try again.</p>
+                return f"""
+                <div class='alert alert-error'>
+                    Error: {str(e)}
                 </div>
                 """
 
         end_consultation_btn.click(
             fn=complete_consultation,
-            inputs=[session_state],
-            outputs=[session_state, completion_status]
+            inputs=[appointment_id],
+            outputs=completion_status
         )
-        
+
     try:
         interface.launch()
     except Exception as e:
-        logger.error(f"Failed to launch interface: {str(e)}")
-        raise
+        logging.error(f"Failed to launch interface: {str(e)}")
+        raise RuntimeError("Failed to launch MediSync interface") from e
+
 
 if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
     create_interface()