updated code , for new feature✅✅

mediSync/app.py

@@ -385,6 +385,383 @@ class MediSyncApp:
             return "<p>Error displaying visualization.</p>"
 
 
+import logging
+import os
+import sys
+import tempfile
+from pathlib import Path
+import requests
+import gradio as gr
+import matplotlib.pyplot as plt
+from PIL import Image
+import json
+
+# Add parent directory to path
+parent_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(parent_dir)
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(), logging.FileHandler("mediSync.log")],
+)
+logger = logging.getLogger(__name__)
+
+class MediSyncApp:
+    """
+    Main application class for the MediSync multi-modal medical analysis system.
+    """
+
+    def __init__(self):
+        """Initialize the application and load models."""
+        self.logger = logging.getLogger(__name__)
+        self.logger.info("Initializing MediSync application")
+        self._temp_files = []  # Track temporary files for cleanup
+        self.fusion_model = None
+        self.image_model = None
+        self.text_model = None
+
+    def __del__(self):
+        """Cleanup temporary files on object destruction."""
+        self.cleanup_temp_files()
+
+    def cleanup_temp_files(self):
+        """Clean up temporary files."""
+        for temp_file in self._temp_files:
+            try:
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+                    self.logger.debug(f"Cleaned up temporary file: {temp_file}")
+            except Exception as e:
+                self.logger.warning(f"Failed to clean up temporary file {temp_file}: {e}")
+        self._temp_files = []
+
+    def load_models(self):
+        """
+        Load models if not already loaded.
+
+        Returns:
+            bool: True if models loaded successfully, False otherwise
+        """
+        if self.fusion_model is not None:
+            return True
+
+        try:
+            self.logger.info("Loading models...")
+            # For now, we'll create a simple mock implementation
+            # You can replace this with your actual model loading code
+            self.logger.info("Models loaded successfully (mock implementation)")
+            return True
+        except Exception as e:
+            self.logger.error(f"Error loading models: {e}")
+            return False
+
+    def enhance_image(self, image):
+        """Enhance the uploaded image."""
+        if image is None:
+            return None
+        
+        try:
+            # Simple image enhancement (you can replace with actual enhancement logic)
+            enhanced_image = image
+            self.logger.info("Image enhanced successfully")
+            return enhanced_image
+        except Exception as e:
+            self.logger.error(f"Error enhancing image: {e}")
+            return image
+
+    def analyze_image(self, image):
+        """
+        Analyze a medical image.
+
+        Args:
+            image: Image file uploaded through Gradio
+
+        Returns:
+            tuple: (image, image_results_html, plot_as_html)
+        """
+        if image is None:
+            return None, "Please upload an image first.", None
+
+        if not self.load_models():
+            return image, "Error: Models not loaded properly.", None
+
+        try:
+            self.logger.info("Analyzing image")
+            
+            # Mock analysis results (replace with actual model inference)
+            results = {
+                "primary_finding": "Normal chest X-ray",
+                "confidence": 0.85,
+                "has_abnormality": False,
+                "predictions": [
+                    ("Normal", 0.85),
+                    ("Pneumonia", 0.10),
+                    ("Cardiomegaly", 0.05)
+                ]
+            }
+
+            # Create visualization
+            fig = self.plot_image_prediction(
+                image,
+                results.get("predictions", []),
+                f"Primary Finding: {results.get('primary_finding', 'Unknown')}"
+            )
+
+            # Convert to HTML for display
+            plot_html = self.fig_to_html(fig)
+            plt.close(fig)  # Clean up matplotlib figure
+
+            # Format results as HTML
+            html_result = self.format_image_results(results)
+            
+            return image, html_result, plot_html
+
+        except Exception as e:
+            self.logger.error(f"Error in image analysis: {e}")
+            return image, f"Error analyzing image: {str(e)}", None
+
+    def analyze_text(self, text):
+        """
+        Analyze medical report text.
+
+        Args:
+            text: Medical report text
+
+        Returns:
+            tuple: (processed_text, text_results_html, plot_as_html)
+        """
+        if not text or text.strip() == "":
+            return "", "Please enter medical report text.", None
+
+        if not self.load_models():
+            return text, "Error: Models not loaded properly.", None
+
+        try:
+            self.logger.info("Analyzing text")
+            
+            # Mock text analysis results (replace with actual model inference)
+            results = {
+                "entities": [
+                    {"text": "chest X-ray", "type": "PROCEDURE", "confidence": 0.95},
+                    {"text": "55-year-old male", "type": "PATIENT", "confidence": 0.90},
+                    {"text": "cough and fever", "type": "SYMPTOM", "confidence": 0.88}
+                ],
+                "sentiment": "neutral",
+                "key_findings": ["Normal heart size", "Clear lungs", "8mm nodular opacity"]
+            }
+
+            # Format results as HTML
+            html_result = self.format_text_results(results)
+            
+            # Create entity visualization
+            plot_html = self.create_entity_visualization(results["entities"])
+            
+            return text, html_result, plot_html
+
+        except Exception as e:
+            self.logger.error(f"Error in text analysis: {e}")
+            return text, f"Error analyzing text: {str(e)}", None
+
+    def analyze_multimodal(self, image, text):
+        """
+        Analyze both image and text together.
+
+        Args:
+            image: Medical image
+            text: Medical report text
+
+        Returns:
+            tuple: (results_html, plot_as_html)
+        """
+        if image is None and (not text or text.strip() == ""):
+            return "Please provide either an image or text for analysis.", None
+
+        if not self.load_models():
+            return "Error: Models not loaded properly.", None
+
+        try:
+            self.logger.info("Performing multimodal analysis")
+            
+            # Mock multimodal analysis results (replace with actual model inference)
+            results = {
+                "combined_finding": "Normal chest X-ray with minor findings",
+                "confidence": 0.92,
+                "image_contribution": "Normal cardiac silhouette and clear lung fields",
+                "text_contribution": "Clinical history supports normal findings",
+                "recommendations": [
+                    "Follow-up CT for the 8mm nodular opacity",
+                    "Monitor for any changes in symptoms"
+                ]
+            }
+
+            # Format results as HTML
+            html_result = self.format_multimodal_results(results)
+            
+            # Create combined visualization
+            plot_html = self.create_multimodal_visualization(results)
+            
+            return html_result, plot_html
+
+        except Exception as e:
+            self.logger.error(f"Error in multimodal analysis: {e}")
+            return f"Error in multimodal analysis: {str(e)}", None
+
+    def format_image_results(self, results):
+        """Format image analysis results as HTML."""
+        html_result = f"""
+        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 10px; margin: 10px 0;">
+            <h2 style="color: #007bff;">X-ray Analysis Results</h2>
+            <p><strong>Primary Finding:</strong> {results.get("primary_finding", "Unknown")}</p>
+            <p><strong>Confidence:</strong> {results.get("confidence", 0):.1%}</p>
+            <p><strong>Abnormality Detected:</strong> {"Yes" if results.get("has_abnormality", False) else "No"}</p>
+            
+            <h3>Top Predictions:</h3>
+            <ul>
+        """
+
+        for label, prob in results.get("predictions", [])[:5]:
+            html_result += f"<li>{label}: {prob:.1%}</li>"
+
+        html_result += "</ul></div>"
+        return html_result
+
+    def format_text_results(self, results):
+        """Format text analysis results as HTML."""
+        html_result = f"""
+        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 10px; margin: 10px 0;">
+            <h2 style="color: #28a745;">Text Analysis Results</h2>
+            <p><strong>Sentiment:</strong> {results.get("sentiment", "Unknown").title()}</p>
+            
+            <h3>Key Findings:</h3>
+            <ul>
+        """
+        
+        for finding in results.get("key_findings", []):
+            html_result += f"<li>{finding}</li>"
+        
+        html_result += "</ul>"
+        
+        html_result += "<h3>Extracted Entities:</h3><ul>"
+        for entity in results.get("entities", [])[:5]:
+            html_result += f"<li><strong>{entity['text']}</strong> ({entity['type']}) - {entity['confidence']:.1%}</li>"
+        
+        html_result += "</ul></div>"
+        return html_result
+
+    def format_multimodal_results(self, results):
+        """Format multimodal analysis results as HTML."""
+        html_result = f"""
+        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 10px; margin: 10px 0;">
+            <h2 style="color: #6f42c1;">Multimodal Analysis Results</h2>
+            <p><strong>Combined Finding:</strong> {results.get("combined_finding", "Unknown")}</p>
+            <p><strong>Overall Confidence:</strong> {results.get("confidence", 0):.1%}</p>
+            
+            <h3>Image Contribution:</h3>
+            <p>{results.get("image_contribution", "No image analysis available")}</p>
+            
+            <h3>Text Contribution:</h3>
+            <p>{results.get("text_contribution", "No text analysis available")}</p>
+            
+            <h3>Recommendations:</h3>
+            <ul>
+        """
+        
+        for rec in results.get("recommendations", []):
+            html_result += f"<li>{rec}</li>"
+        
+        html_result += "</ul></div>"
+        return html_result
+
+    def plot_image_prediction(self, image, predictions, title):
+        """Create visualization for image predictions."""
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.imshow(image)
+        ax.set_title(title, fontsize=14, fontweight='bold')
+        ax.axis('off')
+        return fig
+
+    def create_entity_visualization(self, entities):
+        """Create visualization for text entities."""
+        if not entities:
+            return "<p>No entities found in text.</p>"
+        
+        fig, ax = plt.subplots(figsize=(10, 6))
+        
+        entity_types = {}
+        for entity in entities:
+            entity_type = entity['type']
+            if entity_type not in entity_types:
+                entity_types[entity_type] = 0
+            entity_types[entity_type] += 1
+        
+        if entity_types:
+            ax.bar(entity_types.keys(), entity_types.values(), color='skyblue')
+            ax.set_title('Entity Types Found in Text', fontsize=14, fontweight='bold')
+            ax.set_ylabel('Count')
+            plt.xticks(rotation=45)
+        
+        return self.fig_to_html(fig)
+
+    def create_multimodal_visualization(self, results):
+        """Create visualization for multimodal results."""
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
+        
+        # Confidence visualization
+        confidence = results.get("confidence", 0)
+        ax1.pie([confidence, 1-confidence], labels=['Confidence', 'Uncertainty'], 
+                colors=['lightgreen', 'lightcoral'], autopct='%1.1f%%')
+        ax1.set_title('Analysis Confidence', fontweight='bold')
+        
+        # Recommendations count
+        recommendations = results.get("recommendations", [])
+        ax2.bar(['Recommendations'], [len(recommendations)], color='lightblue')
+        ax2.set_title('Number of Recommendations', fontweight='bold')
+        ax2.set_ylabel('Count')
+        
+        plt.tight_layout()
+        return self.fig_to_html(fig)
+
+    def fig_to_html(self, fig):
+        """Convert matplotlib figure to HTML."""
+        import io
+        import base64
+        
+        buf = io.BytesIO()
+        fig.savefig(buf, format='png', bbox_inches='tight', dpi=100)
+        buf.seek(0)
+        img_str = base64.b64encode(buf.read()).decode()
+        buf.close()
+        
+        return f'<img src="data:image/png;base64,{img_str}" style="max-width: 100%; height: auto;"/>'
+
+def complete_appointment(appointment_id):
+    """
+    Complete an appointment by calling the Flask API.
+    
+    Args:
+        appointment_id: The appointment ID to complete
+        
+    Returns:
+        dict: Response from the API
+    """
+    try:
+        # Call the Flask API to complete the appointment
+        flask_api_url = "http://127.0.0.1:600/complete_appointment"
+        payload = {"appointment_id": appointment_id}
+        
+        response = requests.post(flask_api_url, json=payload, timeout=10)
+        
+        if response.status_code == 200:
+            return {"status": "success", "message": "Appointment completed successfully"}
+        else:
+            return {"status": "error", "message": f"Failed to complete appointment: {response.text}"}
+            
+    except Exception as e:
+        logger.error(f"Error completing appointment: {e}")
+        return {"status": "error", "message": f"Error: {str(e)}"}
+
 def create_interface():
     """Create and launch the Gradio interface."""
 
@@ -433,8 +810,18 @@ def create_interface():
         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
         """)
 
+        # Add appointment ID input
+        with gr.Row():
+            appointment_id_input = gr.Textbox(
+                label="Appointment ID",
+                placeholder="Enter your appointment ID here...",
+                info="This will be automatically populated if you came from the doctors page",
+                value=gr.State("")  # This will be populated via JavaScript
+            )
+
         with gr.Tab("Multimodal Analysis"):
             with gr.Row():
                 with gr.Column():
@@ -507,6 +894,17 @@ def create_interface():
                 label="Example Medical Report",
             )
 
+        # End Consultation Section
+        with gr.Row():
+            with gr.Column():
+                end_consultation_btn = gr.Button(
+                    "End Consultation", 
+                    variant="stop", 
+                    size="lg",
+                    elem_classes=["end-consultation-btn"]
+                )
+                end_consultation_status = gr.HTML(label="Status")
+
         with gr.Tab("About"):
             gr.Markdown("""
             ## About MediSync
@@ -552,12 +950,101 @@ def create_interface():
             outputs=[text_output, text_results, text_plot],
         )
 
+        # End consultation handler
+        def handle_end_consultation(appointment_id):
+            if not appointment_id or appointment_id.strip() == "":
+                return "<div style='color: red; padding: 10px; background-color: #ffe6e6; border-radius: 5px;'>Please enter your appointment ID first.</div>"
+            
+            result = complete_appointment(appointment_id.strip())
+            
+            if result["status"] == "success":
+                # Create success message with redirect button
+                html_response = f"""
+                <div style='color: green; padding: 15px; background-color: #e6ffe6; border-radius: 5px; margin: 10px 0;'>
+                    <h3>✅ Consultation Completed Successfully!</h3>
+                    <p>{result['message']}</p>
+                    <p>Your appointment has been marked as completed.</p>
+                    <button onclick="window.open('http://127.0.0.1:600/doctors', '_blank')" 
+                            style="background-color: #007bff; color: white; padding: 10px 20px; border: none; border-radius: 5px; cursor: pointer; margin-top: 10px;">
+                        Return to Doctors Page
+                    </button>
+                </div>
+                """
+            else:
+                html_response = f"""
+                <div style='color: red; padding: 15px; background-color: #ffe6e6; border-radius: 5px; margin: 10px 0;'>
+                    <h3>❌ Error Completing Consultation</h3>
+                    <p>{result['message']}</p>
+                    <p>Please try again or contact support if the problem persists.</p>
+                </div>
+                """
+            
+            return html_response
+
+        end_consultation_btn.click(
+            handle_end_consultation,
+            inputs=[appointment_id_input],
+            outputs=[end_consultation_status]
+        )
+
+        # Add custom CSS and JavaScript for better styling and functionality
+        gr.HTML("""
+        <style>
+        .end-consultation-btn {
+            background-color: #dc3545 !important;
+            border-color: #dc3545 !important;
+            color: white !important;
+            font-weight: bold !important;
+        }
+        .end-consultation-btn:hover {
+            background-color: #c82333 !important;
+            border-color: #bd2130 !important;
+        }
+        </style>
+        
+        <script>
+        // Function to get URL parameters
+        function getUrlParameter(name) {
+            name = name.replace(/[[]/, '\\[').replace(/[\]]/, '\\]');
+            var regex = new RegExp('[\\?&]' + name + '=([^&#]*)');
+            var results = regex.exec(location.search);
+            return results === null ? '' : decodeURIComponent(results[1].replace(/\+/g, ' '));
+        }
+        
+        // Function to populate appointment ID from URL
+        function populateAppointmentId() {
+            var appointmentId = getUrlParameter('appointment_id');
+            if (appointmentId) {
+                // Find the appointment ID input field and populate it
+                var inputs = document.querySelectorAll('input[type="text"]');
+                for (var i = 0; i < inputs.length; i++) {
+                    if (inputs[i].placeholder && inputs[i].placeholder.includes('appointment ID')) {
+                        inputs[i].value = appointmentId;
+                        break;
+                    }
+                }
+            }
+        }
+        
+        // Run when page loads
+        document.addEventListener('DOMContentLoaded', function() {
+            populateAppointmentId();
+        });
+        
+        // Also run after Gradio loads (in case of dynamic loading)
+        if (typeof gradio !== 'undefined') {
+            gradio.addEventListener('load', function() {
+                setTimeout(populateAppointmentId, 1000);
+            });
+        }
+        </script>
+        """)
+
     # Run the interface
     interface.launch()
 
 
 if __name__ == "__main__":
-    create_interface()
-
+    create_interface() 
 
 # Example Script