Upload casl_analysis.py

casl_analysis.py

@@ -127,17 +127,35 @@ def load_patient_record(record_id):
     """Load patient record from storage"""
     try:
         # Find the record in the CSV file
+        if not os.path.exists(RECORDS_FILE):
+            logger.error(f"Records file does not exist: {RECORDS_FILE}")
+            return None
+            
         with open(RECORDS_FILE, 'r', newline='') as f:
             reader = csv.reader(f)
             next(reader)  # Skip header
             for row in reader:
+                if len(row) < 9:  # Ensure row has enough elements
+                    logger.warning(f"Skipping malformed record row: {row}")
+                    continue
+                    
                 if row[0] == record_id:
                     file_path = row[8]
                     
+                    # Check if the file exists
+                    if not os.path.exists(file_path):
+                        logger.error(f"Analysis file not found: {file_path}")
+                        return None
+                    
                     # Load and return the data
-                    with open(file_path, 'rb') as f:
-                        return pickle.load(f)
+                    try:
+                        with open(file_path, 'rb') as f:
+                            return pickle.load(f)
+                    except (pickle.PickleError, EOFError) as pickle_err:
+                        logger.error(f"Error unpickling file {file_path}: {str(pickle_err)}")
+                        return None
         
+        logger.warning(f"Record ID not found: {record_id}")
         return None
     
     except Exception as e:
@@ -148,27 +166,112 @@ def get_all_patient_records():
     """Return a list of all patient records"""
     try:
         records = []
-        if os.path.exists(RECORDS_FILE):
-            with open(RECORDS_FILE, 'r', newline='') as f:
-                reader = csv.reader(f)
-                next(reader)  # Skip header
-                for row in reader:
-                    records.append({
-                        "id": row[0],
-                        "name": row[1],
-                        "record_id": row[2],
-                        "age": row[3],
-                        "gender": row[4],
-                        "assessment_date": row[5],
-                        "clinician": row[6],
-                        "analysis_date": row[7]
-                    })
+        
+        # Ensure data directories exist
+        ensure_data_dirs()
+        
+        if not os.path.exists(RECORDS_FILE):
+            logger.warning(f"Records file does not exist, creating it: {RECORDS_FILE}")
+            with open(RECORDS_FILE, 'w', newline='') as f:
+                writer = csv.writer(f)
+                writer.writerow([
+                    "ID", "Name", "Record ID", "Age", "Gender", 
+                    "Assessment Date", "Clinician", "Analysis Date", "File Path"
+                ])
+            return records
+            
+        # Read existing records
+        valid_records = []
+        with open(RECORDS_FILE, 'r', newline='') as f:
+            reader = csv.reader(f)
+            next(reader)  # Skip header
+            for row in reader:
+                if len(row) < 9:  # Check for malformed rows
+                    continue
+                    
+                # Check if the analysis file exists
+                file_path = row[8]
+                file_exists = os.path.exists(file_path)
+                
+                record = {
+                    "id": row[0],
+                    "name": row[1],
+                    "record_id": row[2],
+                    "age": row[3],
+                    "gender": row[4],
+                    "assessment_date": row[5],
+                    "clinician": row[6],
+                    "analysis_date": row[7],
+                    "file_path": file_path,
+                    "status": "Valid" if file_exists else "Missing File"
+                }
+                records.append(record)
+                
+                # Keep track of valid records for potential cleanup
+                if file_exists:
+                    valid_records.append(row)
+        
+        # If we found invalid records, consider rewriting the CSV with only valid entries
+        if len(valid_records) < len(records):
+            logger.warning(f"Found {len(records) - len(valid_records)} invalid records")
+            # Uncomment to enable automatic cleanup:
+            # with open(RECORDS_FILE, 'w', newline='') as f:
+            #     writer = csv.writer(f)
+            #     writer.writerow([
+            #         "ID", "Name", "Record ID", "Age", "Gender", 
+            #         "Assessment Date", "Clinician", "Analysis Date", "File Path"
+            #     ])
+            #     for row in valid_records:
+            #         writer.writerow(row)
+        
         return records
     
     except Exception as e:
         logger.error(f"Error getting patient records: {str(e)}")
         return []
 
+def delete_patient_record(record_id):
+    """Delete a patient record"""
+    try:
+        if not os.path.exists(RECORDS_FILE):
+            return False
+            
+        # Find the record and its file
+        file_path = None
+        with open(RECORDS_FILE, 'r', newline='') as f:
+            reader = csv.reader(f)
+            rows = list(reader)
+            header = rows[0]
+            
+            for i, row in enumerate(rows[1:], 1):
+                if len(row) < 9:
+                    continue
+                    
+                if row[0] == record_id:
+                    file_path = row[8]
+                    break
+        
+        if not file_path:
+            return False
+            
+        # Delete the analysis file if it exists
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            
+        # Remove the record from the CSV
+        rows_to_keep = [row for row in rows[1:] if len(row) >= 9 and row[0] != record_id]
+        
+        with open(RECORDS_FILE, 'w', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow(header)
+            writer.writerows(rows_to_keep)
+            
+        return True
+    
+    except Exception as e:
+        logger.error(f"Error deleting patient record: {str(e)}")
+        return False
+
 # ===============================
 # Utility Functions
 # ===============================
@@ -937,8 +1040,11 @@ def generate_report(patient_info, analysis_results, report_type="formal"):
     1. Patient information and assessment details
     2. Summary of findings (strengths and areas of concern)
     3. Detailed analysis of language domains
-    4. Specific recommendations for therapy
+    4. Specific recommendations for therapy that directly address the patient's unique speech patterns
     5. Recommendation for frequency and duration of services
+    6. 2-3 specific questions to ask the patient that target their particular speech difficulties
+    
+    IMPORTANT: For both recommendations and questions, refer to specific examples from the patient's speech sample to make them personalized. Quote exact phrases or patterns from the assessment results when possible.
     
     Use clear, professional language appropriate for {'educational professionals' if report_type == 'formal' else 'parents and caregivers'}.
     Format the report with proper headings and sections.
@@ -1008,6 +1114,14 @@ def generate_report(patient_info, analysis_results, report_type="formal"):
             
             The prognosis for improvement is good with consistent therapeutic intervention and support. Regular reassessment is recommended to monitor progress.
             
+            ## TARGETED QUESTIONS FOR ASSESSMENT FOLLOW-UP
+            
+            1. When you said "we [/] we stayed for &-um three no [//] four days", what strategies could help you remember numbers more confidently?
+            
+            2. I noticed you used phrases like "fishies [: fish] [*]" - can you tell me more about how you decide which word forms to use?
+            
+            3. When you're trying to think of a word like when you said "&-um &-um sprinkles! that's the word", what helps you find the right word?
+            
             Respectfully submitted,
             
             {clinician}
@@ -1072,6 +1186,14 @@ def generate_report(patient_info, analysis_results, report_type="formal"):
             
             With regular therapy and support at home, we expect your child to make good progress in these areas.
             
+            ## QUESTIONS TO ASK AT HOME
+            
+            1. When your child gets stuck looking for a word (like when they said "&-um &-um sprinkles! that's the word"), what helps them find it most effectively?
+            
+            2. Have you noticed if your child uses "fishies" instead of "fish" or similar patterns in other words?
+            
+            3. What activities seem to reduce the number of pauses (&-um) in your child's speech?
+            
             Please reach out with any questions!
             
             {clinician}
@@ -1355,24 +1477,33 @@ def create_interface():
                     with gr.Column(scale=1):
                         gr.Markdown("### Patient Records")
                         
-                        # Records table
+                        # Records table with status column
                         patient_records_table = gr.Dataframe(
-                            headers=["ID", "Name", "Record ID", "Age", "Gender", "Assessment Date", "Clinician"],
-                            datatype=["str", "str", "str", "str", "str", "str", "str"],
+                            headers=["ID", "Name", "Record ID", "Age", "Gender", "Assessment Date", "Clinician", "Status"],
+                            datatype=["str", "str", "str", "str", "str", "str", "str", "str"],
                             label="Saved Patients",
                             interactive=False
                         )
                         
-                        refresh_records_btn = gr.Button("Refresh Records", size="sm")
+                        with gr.Row():
+                            refresh_records_btn = gr.Button("Refresh Records", size="sm")
+                            delete_record_btn = gr.Button("Delete Selected Record", size="sm", variant="secondary")
+                            
                         records_status = gr.Markdown("")
                         
                         # Record selection
                         selected_record_id = gr.Textbox(label="Selected Record ID", visible=False)
-                        load_record_btn = gr.Button("Load Selected Record", variant="primary")
+                        
+                        with gr.Row():
+                            load_record_btn = gr.Button("Load for Analysis", variant="primary")
+                            load_to_report_btn = gr.Button("Load to Report Generator", variant="secondary")
                     
                     with gr.Column(scale=1):
                         # Record details
                         record_details = gr.Markdown(label="Record Details")
+                        
+                        with gr.Accordion("Record Actions", open=False):
+                            export_record_btn = gr.Button("Export Record as PDF", variant="secondary")
                 
                 # Event handlers for records
                 def refresh_patient_records():
@@ -1480,6 +1611,37 @@ def create_interface():
                         status_msg
                     )
                 
+                # Function to load patient record into the report generator tab
+                def load_patient_record_to_report(record_id):
+                    if not record_id:
+                        return gr.update(selected=1), {}, "", "", "", "", "", ""
+                    
+                    record_data = load_patient_record(record_id)
+                    if not record_data:
+                        return gr.update(selected=1), "", "", "", "male", "", "", ""
+                    
+                    # Extract data
+                    patient_info = record_data.get("patient_info", {})
+                    analysis_results = record_data.get("analysis_results", {})
+                    
+                    # Get the raw analysis results as a string
+                    raw_response = analysis_results.get("raw_response", "")
+                    
+                    # Create status message for the record loading
+                    status_msg = f"✅ Record loaded successfully: {patient_info.get('name', 'Unknown')} ({record_id})"
+                    
+                    return (
+                        gr.update(selected=2),  # Switch to Report Generator tab
+                        patient_info.get("name", ""),
+                        patient_info.get("record_id", ""),
+                        patient_info.get("age", ""),
+                        patient_info.get("gender", "male"),
+                        patient_info.get("assessment_date", ""),
+                        patient_info.get("clinician", ""),
+                        raw_response,
+                        status_msg
+                    )
+                
                 load_record_btn.click(
                     load_patient_record_to_analysis,
                     inputs=[selected_record_id],
@@ -1490,6 +1652,17 @@ def create_interface():
                         records_status
                     ]
                 )
+                
+                load_to_report_btn.click(
+                    load_patient_record_to_report,
+                    inputs=[selected_record_id],
+                    outputs=[
+                        main_tabs,
+                        report_patient_name, report_record_id, report_age, report_gender, 
+                        report_date, report_clinician, report_results,
+                        records_status
+                    ]
+                )
             
             # ===============================
             # Report Generator Tab
@@ -1836,15 +2009,21 @@ def create_interface():
             ]
         )
         
-        # Export report functionality
-        def export_pdf(report_text, patient_name="Patient", record_id=""):
+        # Improved PDF export functionality
+        def export_pdf(report_text, patient_name="Patient", record_id="", age="", gender="", assessment_date="", clinician=""):
             try:
                 from reportlab.lib.pagesizes import letter
-                from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+                from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
                 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+                from reportlab.lib import colors
                 import tempfile
                 import webbrowser
                 import os
+                import shutil
+                
+                # Create a proper downloads directory in the app folder
+                downloads_dir = os.path.join(DATA_DIR, "downloads")
+                os.makedirs(downloads_dir, exist_ok=True)
                 
                 # Generate a safe filename
                 if patient_name and record_id:
@@ -1854,20 +2033,20 @@ def create_interface():
                 else:
                     safe_name = f"speech_analysis_{datetime.now().strftime('%Y%m%d%H%M%S')}"
                 
-                # Create a temporary file for the PDF
-                temp_dir = tempfile.gettempdir()
-                pdf_path = os.path.join(temp_dir, f"{safe_name}.pdf")
+                # Create the PDF path in our downloads directory
+                pdf_path = os.path.join(downloads_dir, f"{safe_name}.pdf")
                 
                 # Create the PDF document
                 doc = SimpleDocTemplate(pdf_path, pagesize=letter)
                 styles = getSampleStyleSheet()
                 
-                # Create custom styles
+                # Create enhanced custom styles
                 styles.add(ParagraphStyle(
                     name='Heading1',
                     parent=styles['Heading1'],
                     fontSize=16,
-                    spaceAfter=12
+                    spaceAfter=12,
+                    textColor=colors.navy
                 ))
                 
                 styles.add(ParagraphStyle(
@@ -1875,88 +2054,212 @@ def create_interface():
                     parent=styles['Heading2'],
                     fontSize=14,
                     spaceAfter=10,
-                    spaceBefore=10
+                    spaceBefore=10,
+                    textColor=colors.darkblue
+                ))
+                
+                styles.add(ParagraphStyle(
+                    name='Heading3',
+                    parent=styles['Heading2'],
+                    fontSize=12,
+                    spaceAfter=8,
+                    spaceBefore=8,
+                    textColor=colors.darkblue
                 ))
                 
                 styles.add(ParagraphStyle(
                     name='BodyText',
                     parent=styles['BodyText'],
-                    fontSize=12,
-                    spaceAfter=8
+                    fontSize=11,
+                    spaceAfter=8,
+                    leading=14
+                ))
+                
+                styles.add(ParagraphStyle(
+                    name='BulletPoint',
+                    parent=styles['BodyText'],
+                    fontSize=11,
+                    leftIndent=20,
+                    firstLineIndent=-15,
+                    spaceAfter=4,
+                    leading=14
                 ))
                 
                 # Convert markdown to PDF elements
-                # Very basic conversion - in a real app, use a proper markdown to PDF library
                 story = []
                 
-                # Add title
+                # Add title and date
                 story.append(Paragraph("Speech Language Assessment Report", styles['Title']))
                 story.append(Spacer(1, 12))
                 
-                # Process the markdown content line by line
-                current_style = styles['BodyText']
+                # Add patient information table
+                if patient_name or record_id or age or gender:
+                    # Prepare patient info data
+                    data = []
+                    if patient_name:
+                        data.append(["Patient Name:", patient_name])
+                    if record_id:
+                        data.append(["Record ID:", record_id])
+                    if age:
+                        data.append(["Age:", f"{age} years"])
+                    if gender:
+                        data.append(["Gender:", gender])
+                    if assessment_date:
+                        data.append(["Assessment Date:", assessment_date])
+                    if clinician:
+                        data.append(["Clinician:", clinician])
+                    
+                    if data:
+                        # Create a table with the data
+                        patient_table = Table(data, colWidths=[120, 350])
+                        patient_table.setStyle(TableStyle([
+                            ('BACKGROUND', (0, 0), (0, -1), colors.lightgrey),
+                            ('TEXTCOLOR', (0, 0), (0, -1), colors.darkblue),
+                            ('ALIGN', (0, 0), (0, -1), 'RIGHT'),
+                            ('ALIGN', (1, 0), (1, -1), 'LEFT'),
+                            ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+                            ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+                            ('TOPPADDING', (0, 0), (-1, -1), 6),
+                            ('GRID', (0, 0), (-1, -1), 0.5, colors.lightgrey),
+                        ]))
+                        story.append(patient_table)
+                        story.append(Spacer(1, 12))
+                
+                # Process the markdown content
+                in_bullet_list = False
+                current_list_items = []
                 
                 for line in report_text.split('\n'):
+                    line = line.strip()
+                    
                     # Skip empty lines
-                    if not line.strip():
-                        story.append(Spacer(1, 6))
+                    if not line:
+                        if in_bullet_list:
+                            # End the current list
+                            in_bullet_list = False
+                            for item in current_list_items:
+                                story.append(Paragraph(f"• {item}", styles['BulletPoint']))
+                            current_list_items = []
+                            story.append(Spacer(1, 6))
+                        else:
+                            story.append(Spacer(1, 6))
                         continue
                         
                     # Check for headings
                     if line.startswith('# '):
+                        if in_bullet_list:
+                            # End the current list before starting a new section
+                            in_bullet_list = False
+                            for item in current_list_items:
+                                story.append(Paragraph(f"• {item}", styles['BulletPoint']))
+                            current_list_items = []
                         story.append(Paragraph(line[2:], styles['Heading1']))
                     elif line.startswith('## '):
+                        if in_bullet_list:
+                            # End the current list before starting a new section
+                            in_bullet_list = False
+                            for item in current_list_items:
+                                story.append(Paragraph(f"• {item}", styles['BulletPoint']))
+                            current_list_items = []
                         story.append(Paragraph(line[3:], styles['Heading2']))
+                    elif line.startswith('### '):
+                        if in_bullet_list:
+                            # End the current list before starting a new section
+                            in_bullet_list = False
+                            for item in current_list_items:
+                                story.append(Paragraph(f"• {item}", styles['BulletPoint']))
+                            current_list_items = []
+                        story.append(Paragraph(line[4:], styles['Heading3']))
                     elif line.startswith('- '):
-                        # Bullet points
-                        story.append(Paragraph('• ' + line[2:], styles['BodyText']))
+                        # Bullet points - collect them to process as a list
+                        in_bullet_list = True
+                        current_list_items.append(line[2:])
                     elif line.startswith('**') and line.endswith('**'):
                         # Bold text - assuming it's a short line like a heading
+                        if in_bullet_list:
+                            # End the current list before adding this element
+                            in_bullet_list = False
+                            for item in current_list_items:
+                                story.append(Paragraph(f"• {item}", styles['BulletPoint']))
+                            current_list_items = []
+                        
                         text = line.replace('**', '')
                         story.append(Paragraph(f"<b>{text}</b>", styles['BodyText']))
                     else:
                         # Regular text
-                        story.append(Paragraph(line, styles['BodyText']))
+                        if in_bullet_list:
+                            # End the current list before adding regular text
+                            in_bullet_list = False
+                            for item in current_list_items:
+                                story.append(Paragraph(f"• {item}", styles['BulletPoint']))
+                            current_list_items = []
+                        
+                        # Handle lines with bold text within them
+                        formatted_line = line
+                        bold_pattern = re.compile(r'\*\*(.*?)\*\*')
+                        for match in bold_pattern.finditer(line):
+                            bold_text = match.group(1)
+                            formatted_line = formatted_line.replace(f"**{bold_text}**", f"<b>{bold_text}</b>")
+                        
+                        story.append(Paragraph(formatted_line, styles['BodyText']))
+                
+                # If there are any remaining list items, add them now
+                if in_bullet_list:
+                    for item in current_list_items:
+                        story.append(Paragraph(f"• {item}", styles['BulletPoint']))
+                
+                # Add footer with date
+                footer_text = f"Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+                story.append(Spacer(1, 20))
+                story.append(Paragraph(footer_text, ParagraphStyle(
+                    name='Footer',
+                    parent=styles['Normal'],
+                    fontSize=8,
+                    textColor=colors.grey
+                )))
                 
                 # Build the PDF
                 doc.build(story)
                 
-                # Open the PDF (in a real web app, you'd provide a download link)
-                # This will work in a desktop environment
-                return f"Report saved as PDF: {pdf_path}"
+                # Create a copy in the temp directory to make it accessible in web environments
+                temp_dir = tempfile.gettempdir()
+                temp_pdf_path = os.path.join(temp_dir, f"{safe_name}.pdf")
+                shutil.copy2(pdf_path, temp_pdf_path)
+                
+                return f"Report saved as PDF: {pdf_path}<br>Temporary copy: {temp_pdf_path}"
             
             except Exception as e:
                 logger.exception("Error creating PDF")
-                return f"Error creating PDF: {str(e)}\n\nIn a production environment, we would generate a proper PDF for download."
+                return f"Error creating PDF: {str(e)}"
         
-        # Simplified simulation for HuggingFace Spaces environment
-        def export_pdf_simulation(report_text):
-            return "Report export initiated. In a production environment, a PDF would be generated and downloaded."
+        # Use the full PDF export function regardless of environment
+        export_btn.click(
+            export_pdf,
+            inputs=[
+                full_analysis, 
+                patient_name, 
+                record_id, 
+                age, 
+                gender, 
+                assessment_date, 
+                clinician_name
+            ],
+            outputs=[export_status]
+        )
         
-        # Use the actual function in a desktop environment, simulation in web environment
-        if os.getenv("SPACE_ID"):  # Check if running on HuggingFace Spaces
-            export_btn.click(
-                lambda x: export_pdf_simulation(x),
-                inputs=[full_analysis],
-                outputs=[export_status]
-            )
-            report_download_btn.click(
-                lambda x: export_pdf_simulation(x),
-                inputs=[report_output],
-                outputs=[report_download_status]
-            )
-        else:
-            # Running locally, use actual PDF generation
-            export_btn.click(
-                lambda x, y, z: export_pdf(x, y, z),
-                inputs=[full_analysis, patient_name, record_id],
-                outputs=[export_status]
-            )
-            report_download_btn.click(
-                lambda x, y, z: export_pdf(x, y, z),
-                inputs=[report_output, report_patient_name, report_record_id],
-                outputs=[report_download_status]
-            )
+        report_download_btn.click(
+            export_pdf,
+            inputs=[
+                report_output, 
+                report_patient_name, 
+                report_record_id, 
+                report_age, 
+                report_gender, 
+                report_date, 
+                report_clinician
+            ],
+            outputs=[report_download_status]
+        )
         
         # Report generator button
         def on_generate_report(name, record_id, age, gender, date, clinician, results, report_type):