Update app.py

app.py

@@ -1,55 +1,34 @@
-from flask import Flask, render_template, request, jsonify, session, redirect, url_for, send_file
+from flask import Flask, render_template, request, jsonify, session, redirect
 import google.generativeai as genai
 import PyPDF2
 import os
 import re
-import io
 from datetime import datetime
-from twilio.rest import Client
-from reportlab.lib.pagesizes import letter
-from reportlab.lib import colors
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, ListItem, ListFlowable, Table, TableStyle
-from reportlab.lib.units import inch
-from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
 
 app = Flask(__name__)
-app.secret_key = '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c'  # Add this for session management
 
-upload_base = os.getenv('UPLOAD_DIR', 'static')
+app.secret_key = '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c'  # Add this for session management
+upload_base = os.getenv('UPLOAD_DIR')
 upload_folder = os.path.join(upload_base, 'uploads')
-pdf_folder = os.path.join(upload_base, 'pdfs')
-app.config['UPLOAD_FOLDER'] = upload_folder
-app.config['PDF_FOLDER'] = pdf_folder
 
+app.config['UPLOAD_FOLDER'] = upload_folder
 os.makedirs(upload_folder, exist_ok=True)
-os.makedirs(pdf_folder, exist_ok=True)
-
-# Store patient care plans in memory (would be a database in production)
-if not hasattr(app, 'patient_care_plans'):
-    app.patient_care_plans = []
-
-if not hasattr(app, 'emergency_notifications'):
-    app.emergency_notifications = []
 
 # Gemini API Configuration
-genai.configure(api_key="AIzaSyCizcswP6vlKDMdB3HRAtVi2JbifOpbPvA")
+genai.configure(api_key="AIzaSyD54ejbjVIVa-F3aD_Urnp8m1EFLUGR__I")
+
 generation_config = {
     "temperature": 1,
     "top_p": 0.95,
     "top_k": 40,
     "max_output_tokens": 8192,
 }
+
 model = genai.GenerativeModel(
     model_name="gemini-2.0-flash",
     generation_config=generation_config,
 )
 
-# Twilio Configuration
-ACCOUNT_SID = 'AC490e071f8d01bf0df2f03d086c788d87'
-AUTH_TOKEN = '224b23b950ad5a4052aba15893fdf083'
-TWILIO_FROM = 'whatsapp:+14155238886'
-PATIENT_PHONE = 'whatsapp:+917559355282'  # Hardcoded patient phone number
 
 def extract_text_from_pdf(pdf_file):
     try:
@@ -62,16 +41,17 @@ def extract_text_from_pdf(pdf_file):
         print(f"Error extracting PDF text: {e}")
         return ""
 
+
 def extract_care_plan_format(pdf_text):
     """Extract the care plan format from PDF text"""
     try:
         # Find sections and their content in the PDF using regex
         sections = re.findall(
-            r'([A-Z][A-Z\s]+):(.+?)(?=\n[A-Z][A-Z\s]+:|$)',
+            r'([A-Z][A-Z\s]+)[:|\n]((?:(?!\n[A-Z][A-Z\s]+[:|\n]).)*)',
             pdf_text,
             re.DOTALL
         )
-        
+
         if sections:
             format_template = ""
             for section, content in sections:
@@ -88,279 +68,33 @@ def extract_care_plan_format(pdf_text):
         print(f"Error extracting format: {e}")
         return None
 
-def create_care_plan_pdf(care_plan_text, patient_name="Patient"):
-    """Generate a beautifully formatted PDF with the care plan"""
-    buffer = io.BytesIO()
-    doc = SimpleDocTemplate(buffer, pagesize=letter)
-    styles = getSampleStyleSheet()
-    
-    # Create custom styles
-    styles.add(ParagraphStyle(
-        name='Title',
-        parent=styles['Heading1'],
-        fontSize=18,
-        alignment=TA_CENTER,
-        spaceAfter=20,
-        textColor=colors.HexColor('#0d6efd')
-    ))
-
-    styles.add(ParagraphStyle(
-        name='SectionHeading',
-        parent=styles['Heading2'],
-        fontSize=14,
-        spaceAfter=6,
-        spaceBefore=12,
-        textColor=colors.HexColor('#0a58ca')
-    ))
-
-    styles.add(ParagraphStyle(
-        name='BodyText',
-        parent=styles['Normal'],
-        fontSize=11,
-        alignment=TA_JUSTIFY,
-        spaceBefore=2,
-        spaceAfter=2
-    ))
-
-    # Create story elements
-    story = []
-
-    # Add title with logo
-    timestamp = datetime.now().strftime("%B %d, %Y")
-    title = Paragraph(f"UPDATED CARE PLAN<br/><br/>{timestamp}", styles["Title"])
-    story.append(title)
-    story.append(Spacer(1, 0.25*inch))
-
-    # Patient name
-    patient_info = Paragraph(f"<b>Patient:</b> {patient_name}", styles["BodyText"])
-    story.append(patient_info)
-    story.append(Spacer(1, 0.15*inch))
-
-    # Process care plan sections
-    sections = care_plan_text.split("\n\n")
-    for section in sections:
-        if not section.strip():
-            continue
-            
-        lines = section.strip().split("\n")
-        if not lines:
-            continue
-            
-        # Add section heading
-        heading_line = lines[0].strip()
-        if ":" in heading_line:
-            heading = heading_line.split(":", 1)[0].strip()
-            story.append(Paragraph(heading, styles["SectionHeading"]))
-            
-            # Process bullet points and content
-            content_lines = lines[1:] if len(lines) > 1 else []
-            bullet_items = []
-            normal_text = ""
-            
-            for line in content_lines:
-                line = line.strip()
-                if line.startswith("-") or line.startswith("•"):
-                    bullet_text = line[1:].strip()
-                    bullet_items.append(ListItem(Paragraph(bullet_text, styles["BodyText"])))
-                elif line:  # Only add non-empty lines
-                    normal_text += line + " "
-            
-            # Add normal text if present
-            if normal_text:
-                story.append(Paragraph(normal_text, styles["BodyText"]))
-                
-            # Add bullet points if present
-            if bullet_items:
-                bullet_list = ListFlowable(
-                    bullet_items,
-                    bulletType='bullet',
-                    start=None,
-                    bulletFontName='Helvetica',
-                    bulletFontSize=11,
-                    leftIndent=20,
-                    bulletOffsetY=0
-                )
-                story.append(bullet_list)
-                
-            story.append(Spacer(1, 0.1*inch))
-
-    # Add footer
-    footer_text = """This care plan has been automatically generated based on patient feedback. Please consult with your healthcare provider before making any changes to your current treatment plan."""
-    footer = Paragraph(f"<i>{footer_text}</i>", styles["BodyText"])
-    story.append(Spacer(1, 0.25*inch))
-    story.append(footer)
-
-    # Build PDF
-    doc.build(story)
-    buffer.seek(0)
-    return buffer
-
-def send_whatsapp_message(message, recipient=PATIENT_PHONE, pdf_data=None, pdf_name=None):
-    """
-    Sends a WhatsApp message using Twilio.
-    If pdf_data is provided, it attaches the PDF to the message.
-    """
-    try:
-        client = Client(ACCOUNT_SID, AUTH_TOKEN)
-        
-        # Check if recipient needs WhatsApp prefix
-        if not recipient.startswith('whatsapp:'):
-            recipient = f'whatsapp:{recipient}'
-        
-        message_params = {
-            'from_': TWILIO_FROM,
-            'body': message,
-            'to': recipient
-        }
-        
-        # If we have a PDF to send, attach it
-        if pdf_data and pdf_name:
-            # Create a temporary file
-            temp_pdf_path = os.path.join(app.config['PDF_FOLDER'], pdf_name)
-            with open(temp_pdf_path, 'wb') as f:
-                f.write(pdf_data.getvalue())
-            
-            # In a production environment, we would use a proper URL
-            # For now, inform the user that the PDF would be attached
-            message_params['body'] += "\n\nYour care plan PDF has been generated and would normally be attached here. Please check the web interface to download it."
-        
-        msg = client.messages.create(**message_params)
-        return {
-            'success': True, 
-            'sid': msg.sid
-        }
-    except Exception as e:
-        print(f"Error sending WhatsApp message: {e}")
-        return {
-            'success': False,
-            'error': str(e)
-        }
-
-def determine_status(feedback, old_plan, new_plan):
-    """
-    Determine status of patient based on feedback and comparison of plans
-    Returns: 'emergency', 'warning', or 'normal'
-    """
-    # Emergency keywords to check for severe symptoms
-    emergency_keywords = [
-        # Cardiovascular
-        "severe chest pain", "heart attack", "shortness of breath",
-        "dizziness", "loss of consciousness", "extreme pain",
-
-        # Neurological
-        "sudden weakness", "confusion", "slurred speech", "severe headache",
-
-        # Respiratory
-        "difficulty breathing", "severe shortness of breath", "wheezing", "respiratory distress",
-
-        # Gastrointestinal
-        "severe abdominal pain", "persistent vomiting", "uncontrolled bleeding",
-
-        # Others
-        "severe allergic reaction", "anaphylaxis"
-    ]
-    
-    # Warning keywords for concerning but not emergency conditions
-    warning_keywords = [
-        "pain", "worsening", "not improving", "getting worse", "fever",
-        "nausea", "vomiting", "rash", "diarrhea", "discomfort",
-        "fatigue", "headache", "increase", "swelling", "irregular"
-    ]
-
-    feedback_lower = feedback.lower()
-    
-    # Check for emergency conditions first
-    if any(keyword in feedback_lower for keyword in emergency_keywords):
-        return "emergency"
-    
-    # Check for warning conditions
-    if any(keyword in feedback_lower for keyword in warning_keywords):
-        return "warning"
-    
-    # Compare old and new plans to detect significant changes
-    if old_plan and new_plan:
-        # Use Gemini to compare the plans
-        comparison_prompt = f"""
-        Compare these two care plans and tell me if there are significant changes 
-        that might indicate the patient's condition is deteriorating or improving.
-        Answer only with a single word: "improved", "deteriorated", or "stable".
-        
-        Original care plan:
-        {old_plan}
-        
-        Updated care plan:
-        {new_plan}
-        """
-        
-        try:
-            response = model.generate_content(comparison_prompt)
-            comparison_result = response.text.strip().lower()
-            
-            if "deteriorated" in comparison_result:
-                return "warning"
-            elif "improved" in comparison_result:
-                return "normal"
-            else:
-                return "normal"
-        except Exception as e:
-            print(f"Error comparing plans: {e}")
-            return "normal"
-    
-    return "normal"
 
 @app.route('/')
 def index():
     return render_template('index.html')
 
+
 @app.route('/switch_role', methods=['POST'])
 def switch_role():
     role = request.form.get('role')
     session['role'] = role
     return jsonify({'success': True, 'role': role})
 
+
 @app.route('/doctor_dashboard')
 def doctor_dashboard():
     if session.get('role') != 'doctor':
         return redirect('/')
     return render_template('doctor_dashboard.html')
 
-@app.route('/download_pdf/<filename>')
-def download_pdf(filename):
-    try:
-        return send_file(
-            os.path.join(app.config['PDF_FOLDER'], filename),
-            as_attachment=True,
-            download_name=filename
-        )
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
-
-@app.route('/get_care_plan_details/<plan_id>')
-def get_care_plan_details(plan_id):
-    try:
-        care_plans = getattr(app, 'patient_care_plans', [])
-        plan = next((p for p in care_plans if p.get('id') == plan_id), None)
-        
-        if not plan:
-            return jsonify({'success': False, 'error': 'Care plan not found'})
-            
-        return jsonify({
-            'success': True,
-            'plan': plan
-        })
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
 
 @app.route('/submit_feedback', methods=['POST'])
 def submit_feedback():
     try:
         feedback = request.form.get('feedback', '')
-        patient_name = request.form.get('patient_name', 'Patient')
-        patient_phone = PATIENT_PHONE  # Use the hardcoded phone number
-        
         care_plan_text = ""
         care_plan_format = None
-        
+
         if 'care_plan_pdf' in request.files:
             pdf_file = request.files['care_plan_pdf']
             if pdf_file.filename != '':
@@ -371,38 +105,53 @@ def submit_feedback():
         if not care_plan_format:
             care_plan_format = """
 ASSESSMENT:
-- Assessment details
-
+[Assessment details]
 DAILY CARE PLAN:
-- Morning activities
-- Afternoon activities  
-- Evening activities
-
+Morning:
+- [Morning activities]
+Afternoon:
+- [Afternoon activities]
+Evening:
+- [Evening activities]
 MEDICATIONS:
-- Medication details
-
+- [Medication details]
 ADDITIONAL RECOMMENDATIONS:
-- Recommendations
-
+- [Recommendations]
 FOLLOW-UP:
-- Follow-up details
-"""
+[Follow-up details]
+            """
+
+        # Define emergency keywords to check for severe symptoms
+        emergency_keywords = [
+            # Cardiovascular
+            "severe chest pain", "heart attack", "shortness of breath",
+            "dizziness", "loss of consciousness", "extreme pain",
+
+            # Neurological
+            "sudden weakness", "confusion", "slurred speech", "severe headache",
+
+            # Respiratory
+            "difficulty breathing", "severe shortness of breath", "wheezing", "respiratory distress",
+
+            # Gastrointestinal
+            "severe abdominal pain", "persistent vomiting", "uncontrolled bleeding",
+
+            # Others
+            "severe allergic reaction", "anaphylaxis"
+        ]
 
-        # Determine if this is an emergency situation
-        status = determine_status(feedback, care_plan_text, None)
-        is_emergency = (status == "emergency")
+        feedback_lower = feedback.lower()
+        is_emergency = any(keyword in feedback_lower for keyword in emergency_keywords)
 
         if is_emergency:
             # Store emergency notification
             emergency_data = {
-                'id': datetime.now().strftime("%Y%m%d%H%M%S"),
-                'patient_name': patient_name,
-                'patient_phone': patient_phone,
                 'patient_feedback': feedback,
                 'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                'status': 'emergency'
+                'status': 'urgent'
             }
-            
+            # In a real application, you would store this in a database
+            # For now, we'll use a global variable (not recommended for production)
             if not hasattr(app, 'emergency_notifications'):
                 app.emergency_notifications = []
             app.emergency_notifications.append(emergency_data)
@@ -411,118 +160,49 @@ FOLLOW-UP:
             emergency_message = (
                 "Emergency symptoms detected. Please call emergency services immediately at 104/108/109/112."
             )
-            
-            # Send emergency message to patient
-            send_whatsapp_message(
-                message=emergency_message,
-                recipient=patient_phone
-            )
-                
             return jsonify({
                 'success': True,
-                'is_emergency': True,
-                'status': 'emergency',
                 'updated_plan': emergency_message
             })
 
-        # Prepare a prompt for Gemini AI
+        # Prepare a prompt for Gemini AI for a perfect, attractively formatted day care plan.
         prompt = f"""
 Patient Care Plan Update Request:
-Patient Name: {patient_name}
 Current Symptoms and Feedback: {feedback}
 Current Care Plan (extracted from PDF): {care_plan_text}
-
-Based on the patient's feedback and current care plan, please provide an updated, comprehensive daily care plan in the exact following format:
+Based on the patient's feedback and current care plan, please provide an updated, perfect daily care plan in the exact following format:
 {care_plan_format}
-
 Please ensure the following:
-1. The response is well-structured with clear section headings.
-2. Use bullet points for list items without including any asterisk (*) symbols.
-3. Format the text attractively and professionally.
-4. Remove any extraneous symbols.
-5. Be specific and detailed with recommendations.
+- The response is well-structured with clear section headings.
+- Use bullet points for list items without including any asterisk (*) symbols.
+- Format the text attractively and professionally.
+- Remove any extraneous symbols.
 """
-
         # Get response from Gemini AI
         response = model.generate_content(prompt)
-        
         # Remove any asterisk symbols from the response text
         updated_plan = response.text.replace("*", "")
-        
-        # Determine status based on feedback and plan comparison
-        status = determine_status(feedback, care_plan_text, updated_plan)
-        
-        # Generate PDF
-        pdf_buffer = create_care_plan_pdf(updated_plan, patient_name)
-        
-        # Save the PDF to file system with a unique name
-        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
-        safe_name = re.sub(r'[^a-zA-Z0-9]', '_', patient_name)
-        pdf_filename = f"care_plan_{safe_name}_{timestamp}.pdf"
-        pdf_path = os.path.join(app.config['PDF_FOLDER'], pdf_filename)
-        
-        with open(pdf_path, 'wb') as f:
-            f.write(pdf_buffer.getvalue())
-        
-        # Reset the buffer pointer for potential reuse
-        pdf_buffer.seek(0)
-        
-        # Store care plan data
-        care_plan_data = {
-            'id': timestamp,
-            'patient_name': patient_name,
-            'original_plan': care_plan_text,
-            'updated_plan': updated_plan,
-            'feedback': feedback,
-            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            'pdf_filename': pdf_filename,
-            'status': status
-        }
-        
-        if not hasattr(app, 'patient_care_plans'):
-            app.patient_care_plans = []
-        app.patient_care_plans.append(care_plan_data)
-        
-        # Send WhatsApp message with PDF
-        message_result = send_whatsapp_message(
-            message=f"Hello {patient_name}, your updated care plan is ready based on your feedback. Please review it and contact your healthcare provider if you have any questions.",
-            recipient=patient_phone,
-            pdf_data=pdf_buffer,
-            pdf_name=pdf_filename
-        )
-        
+
         return jsonify({
             'success': True,
-            'updated_plan': updated_plan,
-            'pdf_filename': pdf_filename,
-            'message_sent': message_result['success'] if message_result else False,
-            'is_emergency': False,
-            'status': status
+            'updated_plan': updated_plan
         })
-        
+
     except Exception as e:
-        import traceback
-        traceback.print_exc()
         return jsonify({
             'success': False,
             'error': str(e)
         })
 
+
 @app.route('/get_emergency_notifications')
 def get_emergency_notifications():
     if session.get('role') != 'doctor':
         return jsonify({'success': False, 'error': 'Unauthorized'})
-    
+
     notifications = getattr(app, 'emergency_notifications', [])
     return jsonify({'success': True, 'notifications': notifications})
 
-@app.route('/get_patient_care_plans')
-def get_patient_care_plans():
-    if session.get('role') != 'doctor':
-        return jsonify({'success': False, 'error': 'Unauthorized'})
-    
-    care_plans = getattr(app, 'patient_care_plans', [])
-    return jsonify({'success': True, 'care_plans': care_plans})
 
 if __name__ == '__main__':
     app.run(debug=True)