Update app.py

app.py

@@ -28,6 +28,7 @@ app = Flask(__name__, instance_path='/tmp')
 app.secret_key = os.getenv('SECRET_KEY', '688ed745a74bdd7ac238f5b50f4104fb87d6774b8b0a4e06e7e18ac5ed0fa31c') # CHANGE THIS IN PRODUCTION
 
 # Database Configuration
+# Revert to original DB path if different
 app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:////tmp/patients.db')
 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 
@@ -61,31 +62,20 @@ class Patient(db.Model):
             'timestamp': self.timestamp.strftime("%Y-%m-%d %H:%M:%S") if self.timestamp else None
         }
 
-# Create database tables if they don't exist
-@app.before_request
-def create_tables():
-    # Ensure this runs only once per request or use a flag
-    # Simple approach for development: check if tables exist
-    # Use a flag to prevent running on every request
-    if not getattr(app, '_tables_created', False):
-        with app.app_context():
-            # Check if at least one table exists (e.g., the Patient table)
-            inspector = db.inspect(db.engine)
-            if not inspector.has_table("patient"):
-                logger.info("Creating database tables.")
-                db.create_all()
-            else:
-                logger.info("Database tables already exist.")
-            app._tables_created = True # Set flag
+# Database table creation will be handled in if __name__ == '__main__': block below
 
 
 upload_base = os.getenv('UPLOAD_DIR', '/tmp')
-upload_folder = os.path.join(upload_base, 'uploads', 'pdfs') # Use a sub-directory like 'uploads'
+# Revert upload folder path to the original structure to avoid PermissionError
+upload_folder = os.path.join(upload_base, 'pdfs')
 
 app.config['UPLOAD_FOLDER'] = upload_folder
 
-# Ensure the folder exists at runtime
+# Ensure the folder exists at runtime - This line caused the error with the wrong path
+# It should work now that the path is /tmp/pdfs, assuming /tmp is writable.
+# If /tmp itself is not writable, you'll need to configure UPLOAD_DIR env var.
 os.makedirs(upload_folder, exist_ok=True)
+logger.info(f"Upload folder path set to: {upload_folder}")
 
 
 # Twilio Configuration
@@ -179,49 +169,18 @@ def extract_text_from_pdf(pdf_file):
         return f"[Error extracting PDF text: {e}]"
 
 
+# Reverting extract_care_plan_format as it's not used for AI structure anymore
+# The AI prompt uses a fixed structure. The extracted text is passed as context.
+# Keeping a simplified version in case it was used elsewhere, but it's not critical for the prompt.
 def extract_care_plan_format(pdf_text):
     """Extract a general format template from PDF text by identifying common section headers."""
-    if not pdf_text or "[No readable text found" in pdf_text or "[Error extracting PDF text" in pdf_text or "[PDF Content Unavailable" in pdf_text:
-        logger.info("No valid PDF text available to extract format.")
-        return None
-
-    # Look for lines that seem like headers followed by a colon, period, or are just standalone capitalized lines
-    # Refined Pattern: Start of line, followed by one or more uppercase letters or spaces/words, ending with colon/period or followed by newline/indentation.
-    # Let's stick to the colon/period heuristic first as it's more reliable for structured docs.
-    # Pattern: Start of line ^, followed by one or more word characters (\w+) or spaces (\s), potentially including lowercase letters now `[A-Za-z\s]`, ending with a colon `:` or period `.` and then potentially space or end of line `$`.
-    # Add lookahead for newlines/spaces to handle headers that are the last line or followed by blank space.
-    potential_headers = re.findall(r'^[A-Z][A-Za-z\s]*[:.]?(?:\s|$)', pdf_text, re.MULTILINE)
-    # Further filter to exclude things that are likely sentence fragments or short lines
-    potential_headers = [h.strip() for h in potential_headers if h.strip() and len(h.strip().split()) > 1 and len(h.strip()) > 5] # Filter short/single word lines
-
-    if not potential_headers:
-         logger.info("No potential headers found in PDF text.")
-         return None
-
-    # Use a set to get unique headers, remove trailing colon/period, strip, and sort
-    unique_headers = sorted(list(set([re.sub(r'[:.\s]*$', '', h).strip() for h in potential_headers if re.sub(r'[:.\s]*$', '', h).strip()])))
-
-    if not unique_headers:
-         logger.info("Extracted headers are empty after cleaning.")
-         return None
-
-    # Construct a format template string
-    # We don't need to represent the *exact* sub-structure with [Details] anymore,
-    # just the main sections. The AI will be instructed to follow a specific *required* structure.
-    # This extraction is mostly for informing the AI about *potential* sections present in the original.
-    # However, the user wants a *fixed* template structure regardless of the PDF.
-    # Let's *ignore* the extracted format for the AI prompt and rely solely on the hardcoded one.
-    # The extracted text itself is what's important from the PDF, not its format template.
-    # So, we can simplify this function or remove it if the AI strictly uses a hardcoded template.
-
-    # Given the user wants a FIXED template in the AI output, this extraction function's
-    # primary use becomes less critical for *generating* the new plan's format,
-    # but it *does* provide context about the original plan's content organization.
-    # Let's keep it simple, just return the extracted text. The prompt handles the structure.
-    return None # We will rely on the hardcoded structure in the prompt
-
-
-# --- OPTIMIZED determine_patient_status FUNCTION ---
+    # Simplified: The AI uses a fixed template. This function might just return None
+    # or the raw text if needed for some other purpose (it wasn't clearly used elsewhere).
+    # Let's return None as the AI prompt defines the structure.
+    return None
+
+
+# --- OPTIMIZED determine_patient_status FUNCTION (Keeping this as it's needed) ---
 def determine_patient_status(original_plan, updated_plan, feedback):
     """
     Determine patient status based on feedback, original plan, and the *final* updated plan text.
@@ -291,25 +250,12 @@ def determine_patient_status(original_plan, updated_plan, feedback):
 
     # Helper to check if any keyword is found in the text
     def check_keywords(text, keywords):
-        # Create a regex pattern for whole words, handling potential special characters in keywords
-        # Ensure keywords match whole words or are at word boundaries
-        pattern = r'\b(?:' + '|'.join(re.escape(kw) for kw in keywords) + r')\b'
-        # Also check for phrases that might not be whole words at the start/end, but contain spaces
-        # e.g., "severe chest pain" might be part of "patient reports severe chest pain"
-        # A simple join with | might miss this if not careful about word boundaries.
-        # Let's rely on the \b boundaries which should work for multi-word phrases too if surrounded by non-word chars or boundaries.
-        # Alternative: simple `in` check might be less precise but catches more variations.
-        # Let's use the regex but ensure it's robust. Adding spaces around keywords in pattern? No, \b is better.
-        # Let's also include a fallback simple 'in' check for keywords with spaces that might be tricky.
+        # Use regex with word boundaries for precision
         for kw in keywords:
             if re.search(r'\b' + re.escape(kw) + r'\b', text):
                  return True
-        # Fallback check for phrases that might not strictly align with \b everywhere
-        # This is less precise, but can catch things like "patient reports severe chest pain".
-        # Let's stick to the more precise regex for now, as loose matching can lead to false positives.
         return False
 
-
     # --- Classification Logic ---
 
     # Combine feedback and original plan text for initial assessment
@@ -323,7 +269,6 @@ def determine_patient_status(original_plan, updated_plan, feedback):
 
     # 1. Check for EMERGENCY status (Highest Priority)
     # Check the final combined text (feedback + updated plan) for emergency keywords.
-    # This ensures if the AI generates text indicating emergency, it's caught.
     is_emergency = check_keywords(combined_final_text_lower, emergency_keywords)
 
     if is_emergency:
@@ -334,8 +279,6 @@ def determine_patient_status(original_plan, updated_plan, feedback):
     # Check the final combined text for deteriorating keywords (only if not emergency)
     is_deteriorating = check_keywords(combined_final_text_lower, deteriorating_keywords)
     if is_deteriorating:
-        # Add a check to see if improving keywords are also present - prioritize improving if both are there?
-        # Or assume deteriorating overrides improving? Let's assume deteriorating is higher priority.
         logger.info("Status determined: DETERIORATING (keyword found in feedback/final plan).")
         return "deteriorating"
 
@@ -351,6 +294,7 @@ def determine_patient_status(original_plan, updated_plan, feedback):
     return "stable"
 
 
+# --- generate_care_plan_pdf function (Keeping improvements) ---
 def generate_care_plan_pdf(patient_info, care_plan_text, status):
     """Generate a PDF of the care plan with improved styling"""
     buffer = io.BytesIO()
@@ -486,33 +430,26 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         # Check for section headers (e.g., "MEDICATIONS:", "ASSESSMENT:")
         # Look for lines starting with one or more uppercase words followed by a colon or period,
         # or lines that are entirely uppercase words (might be headers without colon).
-        # Pattern: ^ Start of line, ([A-Z][A-Za-z\s]*): Captures words/spaces starting with Capital.
-        # [:. ]? Optional colon/period/space. ($|\n) Followed by end of line or newline (accounts for empty lines after header).
-        # Added check for lines that are ALL CAPS and maybe don't have a colon/period.
-        header_match = re.match(r'^([A-Z][A-Za-z\s]*)\s*[:.]?$', stripped_line) # Looks for headers ending in optional colon/period/space
-        all_caps_match = re.match(r'^[A-Z\s]+$', stripped_line) # Looks for lines that are all caps
-
-        if header_match or (all_caps_match and len(stripped_line.split()) > 1): # Consider all-caps lines with >1 word headers
-            # Clean up header text - remove trailing colon/period/whitespace
+        header_match = re.match(r'^([A-Z][A-Za-z\s]*)\s*[:.]?$', stripped_line)
+        all_caps_match = re.match(r'^[A-Z\s]+$', stripped_line)
+
+        if header_match or (all_caps_match and len(stripped_line.split()) > 1):
             header_text = re.sub(r'[:.\s]*$', '', stripped_line).strip()
-            if header_text: # Only add if header text isn't empty after cleaning
+            if header_text:
                 story.append(Spacer(1, 8)) # Add space before a new section
                 story.append(Paragraph(header_text + ":", heading_style)) # Use heading style for sections
         # Check for list items (starting with -, *, •)
         elif stripped_line.startswith('-') or stripped_line.startswith('*') or stripped_line.startswith('•'):
-             # Remove the bullet character and any leading space/tab
-             bullet_text = re.sub(r'^[-*•][ \t]*', '', line).strip() # Use original line to preserve indentation? No, strip is better.
+             bullet_text = re.sub(r'^[-*•][ \t]*', '', line).strip()
              if bullet_text:
-                 # Replace newline with <br/> for ReportLab within bullet text
                  formatted_bullet_text = bullet_text.replace('\n', '<br/>')
                  story.append(Paragraph(f"• {formatted_bullet_text}", bullet_style))
              else:
-                 # Handle cases with just a bullet point on a line
                  story.append(Paragraph("• ", bullet_style))
         else:
             # Handle regular paragraph text
             normal_line_content = line.strip().replace('\n', '<br/>')
-            if normal_line_content: # Only add if not empty after cleaning
+            if normal_line_content:
                 story.append(Paragraph(normal_line_content, normal_style))
 
 
@@ -536,6 +473,7 @@ def generate_care_plan_pdf(patient_info, care_plan_text, status):
         return error_buffer
 
 
+# --- send_whatsapp_care_plan function (Keeping improvements) ---
 def send_whatsapp_care_plan(patient_info, care_plan_text, status):
     """Send care plan via WhatsApp using Twilio with improved formatting"""
     if not twilio_client:
@@ -567,11 +505,10 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
         # Replace common list bullet formats with WhatsApp bullet
         formatted_plan = formatted_plan.replace('- ', '• ').replace('* ', '• ')
 
-        # Attempt to bold section headers - look for lines ending with a colon or period, potentially followed by whitespace
-        # Use the same pattern as in PDF generation for consistency
+        # Attempt to bold section headers
         formatted_plan_lines = []
         lines = formatted_plan.split('\n')
-        for i, line in enumerate(lines):
+        for line in lines:
              stripped_line = line.strip()
              if not stripped_line:
                  formatted_plan_lines.append("") # Keep empty lines for spacing
@@ -582,7 +519,6 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
              all_caps_match = re.match(r'^[A-Z\s]+$', stripped_line)
 
              if header_match or (all_caps_match and len(stripped_line.split()) > 1):
-                  # Clean up header text - remove trailing colon/period/whitespace
                   header_text = re.sub(r'[:.\s]*$', '', stripped_line).strip()
                   if header_text:
                     formatted_plan_lines.append(f"*{header_text.upper()}:*") # Bold and capitalize for clarity
@@ -590,8 +526,6 @@ def send_whatsapp_care_plan(patient_info, care_plan_text, status):
                      formatted_plan_lines.append(line) # Add original line if cleaning results in empty
              # Check for bullet points
              elif stripped_line.startswith('•'):
-                 # Ensure consistent bullet point and formatting
-                 # If the AI uses "-", replace it earlier. Here, just format the text after "•"
                  bullet_content = re.sub(r'^•[ \t]*', '', line).strip() # Get text after bullet
                  formatted_plan_lines.append(f"• {bullet_content}") # Add WhatsApp bullet
              else:
@@ -785,10 +719,11 @@ SYMPTOM MANAGEMENT:
             )
             # Status remains 'emergency', which was already set as final_status_to_save.
 
+
         elif ai_enabled: # AI is enabled and initial status is not emergency
             logger.info("AI is enabled and status is not emergency. Generating plan via AI.")
 
-            # --- MODIFIED AND OPTIMIZED AI PROMPT ---
+            # --- MODIFIED AND OPTIMIZED AI PROMPT (Keeping this from previous) ---
             prompt = f"""
 You are an expert AI assistant specialized in generating concise, structured patient care plans.
 
@@ -821,13 +756,14 @@ Gender: {gender}
 8. Do NOT use any vague placeholders like "(To be added)", "(Not provided)", or "(Unknown)" anywhere in the plan. If information is truly unavailable and you cannot infer a reasonable default (like suggesting a type of medication), omit the specific detail rather than using a placeholder.
 9. Do NOT include any introductory phrases (e.g., "Here is the plan", "Based on your feedback") or concluding remarks outside the plan structure. Provide ONLY the structured content.
 10. Ensure the plan's tone and content are appropriate for the patient's determined status (Deteriorating, Improving, Stable). For deteriorating status, emphasize caution and monitoring. For improving, suggest gradual progression if appropriate.
-11. Respond ONLY with the text that follows the "Required Care Plan Structure".
+11. Review the feedback and previous plan carefully to determine the most likely current STATUS (e.g., Emergency, Deteriorating, Improving, Stable) and ensure the plan content aligns with that status.
 
 --- Required Care Plan Structure (Use ONLY these exact sections and sub-sections in this order) ---
 {required_care_plan_structure}
 """
             # --- END OF MODIFIED AI PROMPT ---
 
+
             logger.info("Sending prompt to AI model...")
 
             try:
@@ -837,21 +773,17 @@ Gender: {gender}
 
                 # Remove markdown code block formatting if present
                 if generated_plan_text.startswith('```'):
-                    # Find the first newline after ``` to potentially strip language name
                     first_newline_after_code = generated_plan_text.find('\n')
                     if first_newline_after_code != -1:
-                        # Check if there's a language name before the newline
-                        potential_lang = generated_plan_text[3:first_newline_after_code].strip()
-                        if re.match(r'^[a-zA-Z0-9]+$', potential_lang): # Simple check for language name
-                             generated_plan_text = generated_plan_text[first_newline_after_code:].strip()
-                        else:
-                             # No language name or unexpected format, just strip ```
-                             generated_plan_text = generated_plan_text[3:].strip()
+                         # Check if there's a language name before the newline
+                         potential_lang = generated_plan_text[3:first_newline_after_code].strip()
+                         if re.match(r'^[a-zA-Z0-9]+$', potential_lang): # Simple check for language name
+                              generated_plan_text = generated_plan_text[first_newline_after_code:].strip()
+                         else:
+                              generated_plan_text = generated_plan_text[3:].strip()
                     else:
-                         # Handle case where ``` is on the last line without newline
-                         generated_plan_text = generated_plan_text[3:].strip()
+                          generated_plan_text = generated_plan_text[3:].strip()
 
-                    # Strip ending ```
                     if generated_plan_text.endswith('```'):
                         generated_plan_text = generated_plan_text[:-3].strip()
 
@@ -859,9 +791,6 @@ Gender: {gender}
                 logger.info(f"AI Response received. Length: {len(generated_plan_text)}")
 
                 # Re-determine the final status using the generated plan as well.
-                # This is important because the AI might infer severity the keyword matching missed initially,
-                # or the generated plan text itself might contain explicit strong status indicators.
-                # Pass original_plan_text again for context if needed by the status function, but updated_plan_text is key here.
                 final_status_to_save = determine_patient_status(care_plan_text, generated_plan_text, feedback)
                 logger.info(f"Final status determined after AI generation: {final_status_to_save}")
 
@@ -918,15 +847,12 @@ Gender: {gender}
         logger.info(f"Patient {patient_id} added to DB with status: {final_status_to_save}.")
 
         # Generate PDF for downloading using the stored data
-        # Note: We pass the patient object directly to the PDF generator for simplicity
-        # and to include feedback in the PDF. PDF generator reads updated_plan from the object.
         pdf_buffer = generate_care_plan_pdf(new_patient.to_dict(), new_patient.updated_plan, new_patient.status)
         pdf_buffer.seek(0) # Ensure buffer is at the start before base64 encoding
         pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode('utf-8')
         logger.info("PDF generated and base64 encoded.")
 
         # Send care plan via WhatsApp (using the final saved data)
-        # Note: We pass the patient object directly to the WhatsApp function.
         whatsapp_sent, whatsapp_message = send_whatsapp_care_plan(new_patient.to_dict(), new_patient.updated_plan, new_patient.status)
         logger.info(f"WhatsApp message attempt sent: {whatsapp_sent}, message: {whatsapp_message}")
 
@@ -951,7 +877,7 @@ Gender: {gender}
             'error': f'An unexpected server error occurred: {str(e)}'
         }), 500
 
-# --- New routes for Doctor Dashboard actions ---
+# --- New routes for Doctor Dashboard actions (Keeping these) ---
 
 @app.route('/update_care_plan/<patient_id>', methods=['PUT'])
 def update_care_plan(patient_id):
@@ -970,9 +896,7 @@ def update_care_plan(patient_id):
             logger.warning(f"Update failed for ID {patient_id}: Patient not found.")
             return jsonify({'success': False, 'error': 'Patient not found.'}), 404
 
-        # Re-determine status based on the manually updated plan + existing feedback/original?
-        # Yes, this makes sense. If the doctor edits the plan, it should potentially change the status indication
-        # if their edits include stronger language about severity or improvement.
+        # Re-determine status based on the manually updated plan + existing feedback/original
         patient.status = determine_patient_status(patient.original_plan, updated_plan_text, patient.feedback)
 
         patient.updated_plan = updated_plan_text
@@ -1020,8 +944,6 @@ def send_whatsapp_doctor(patient_id):
             return jsonify({'success': True, 'message': whatsapp_message})
         else:
             logger.error(f"WhatsApp failed for patient ID: {patient_id} - {whatsapp_message}")
-            # Use 500 for server-side error only if it's a backend issue, otherwise 400 maybe?
-            # Let's stick to 500 for general failure to send via backend service.
             return jsonify({'success': False, 'error': whatsapp_message}), 500
 
     except Exception as e:
@@ -1136,16 +1058,14 @@ def delete_patient(patient_id):
 
 if __name__ == '__main__':
     # Create database tables if they don't exist within the application context
+    # This is the standard place for create_all() for simpler apps
     with app.app_context():
-        # Use the flag to avoid re-creating tables on every `run` if hot-reloading
-        if not getattr(app, '_tables_created', False):
-             inspector = db.inspect(db.engine)
-             if not inspector.has_table("patient"): # Check for at least one model's table
-                  logger.info("Database tables not found, creating.")
-                  db.create_all()
-             else:
-                  logger.info("Database tables already exist.")
-             app._tables_created = True # Set flag after creation/check
+        inspector = db.inspect(db.engine)
+        if not inspector.has_table("patient"): # Check for at least one model's table
+             logger.info("Database tables not found, creating.")
+             db.create_all()
+        else:
+             logger.info("Database tables already exist.")
 
     # Use a more robust development server like Waitress or Gunicorn in production
     # For development, debug=True is fine