#!/usr/bin/env python3 """ Report generator for CASL Voice Bot. This module generates assessment reports based on session data. """ import os import json import pandas as pd import matplotlib.pyplot as plt from pathlib import Path from datetime import datetime import jinja2 class CASLReportGenerator: """Generates reports from session data""" def __init__(self, session_data_dir="session_data", reports_dir="reports"): """Initialize the report generator""" self.session_data_dir = session_data_dir self.reports_dir = reports_dir # Create directories if they don't exist Path(session_data_dir).mkdir(exist_ok=True) Path(reports_dir).mkdir(exist_ok=True) # Set up Jinja2 template environment self.template_loader = jinja2.FileSystemLoader(searchpath="./templates") self.template_env = jinja2.Environment(loader=self.template_loader) def load_session_data(self, filename=None, student_id=None): """Load session data from file or by student ID""" if filename: with open(os.path.join(self.session_data_dir, filename), 'r') as f: return json.load(f) elif student_id: # Find all files for this student files = [f for f in os.listdir(self.session_data_dir) if f.startswith(f"{student_id}_") and f.endswith(".json")] if not files: return None # Sort by date (newest first) and load the most recent files.sort(reverse=True) with open(os.path.join(self.session_data_dir, files[0]), 'r') as f: return json.load(f) return None def load_all_student_sessions(self, student_id): """Load all sessions for a specific student""" files = [f for f in os.listdir(self.session_data_dir) if f.startswith(f"{student_id}_") and f.endswith(".json")] sessions = [] for file in sorted(files): with open(os.path.join(self.session_data_dir, file), 'r') as f: sessions.append(json.load(f)) return sessions def extract_casl_metrics(self, session_data): """Extract CASL-2 metrics from session data""" metrics = { "lexical_semantic": 0, "syntactic": 0, "supralinguistic": 0, "pragmatic": 0 } # Count assessment notes per category assessment = session_data.get("assessment", {}) for category, notes in assessment.items(): if category in metrics: metrics[category] = len(notes) return metrics def generate_progress_chart(self, student_id, output_path=None): """Generate a progress chart for a student""" sessions = self.load_all_student_sessions(student_id) if not sessions: return None # Extract dates and metrics dates = [] metrics = { "lexical_semantic": [], "syntactic": [], "supralinguistic": [], "pragmatic": [] } for session in sessions: dates.append(datetime.fromisoformat(session["timestamp"]).strftime("%m/%d/%Y")) session_metrics = self.extract_casl_metrics(session) for category in metrics: metrics[category].append(session_metrics.get(category, 0)) # Create chart plt.figure(figsize=(10, 6)) for category, values in metrics.items(): plt.plot(dates, values, marker='o', label=category.replace('_', ' ').title()) plt.title(f"CASL-2 Assessment Progress for Student {student_id}") plt.xlabel("Session Date") plt.ylabel("Assessment Score") plt.legend() plt.xticks(rotation=45) plt.tight_layout() # Save or return if output_path: plt.savefig(output_path) return output_path else: chart_path = os.path.join(self.reports_dir, f"{student_id}_progress.png") plt.savefig(chart_path) return chart_path def generate_session_summary(self, session_data): """Generate a summary of a single session""" if not session_data: return None # Extract basic info timestamp = datetime.fromisoformat(session_data["timestamp"]) student_id = session_data.get("student_id", "anonymous") # Extract transcript transcript = session_data.get("transcript", []) # Calculate metrics word_count = 0 student_turns = 0 for entry in transcript: if entry.get("speaker") == "Student": text = entry.get("text", "") words = text.split() word_count += len(words) student_turns += 1 # Get CASL-2 metrics casl_metrics = self.extract_casl_metrics(session_data) # Create summary summary = { "date": timestamp.strftime("%m/%d/%Y"), "time": timestamp.strftime("%H:%M"), "student_id": student_id, "duration_minutes": len(transcript) // 2, # Approximate based on turns "student_turns": student_turns, "total_words": word_count, "average_words_per_turn": word_count / max(1, student_turns), "casl_metrics": casl_metrics } return summary def generate_html_report(self, student_id, output_path=None): """Generate an HTML report for a student""" # Load all sessions for the student sessions = self.load_all_student_sessions(student_id) if not sessions: return None # Generate progress chart chart_path = self.generate_progress_chart(student_id) # Get latest session data latest_session = sessions[-1] latest_summary = self.generate_session_summary(latest_session) # Calculate overall progress if len(sessions) > 1: first_metrics = self.extract_casl_metrics(sessions[0]) latest_metrics = self.extract_casl_metrics(sessions[-1]) progress = {} for category in first_metrics: if first_metrics[category] > 0: progress[category] = (latest_metrics[category] - first_metrics[category]) / first_metrics[category] else: progress[category] = 0 if latest_metrics[category] == 0 else 1 else: progress = {category: 0 for category in latest_summary["casl_metrics"]} # Prepare report data report_data = { "student_id": student_id, "report_date": datetime.now().strftime("%m/%d/%Y"), "session_count": len(sessions), "latest_session": latest_summary, "progress": progress, "chart_path": os.path.basename(chart_path), "recommendations": self.generate_recommendations(sessions) } # Load and render template try: template = self.template_env.get_template("report_template.html") report_html = template.render(**report_data) # Save report if not output_path: output_path = os.path.join(self.reports_dir, f"{student_id}_report.html") with open(output_path, 'w') as f: f.write(report_html) return output_path except jinja2.exceptions.TemplateNotFound: # Create a simple report if template is not found report = f"CASL-2 Assessment Report for Student {student_id}\n" report += f"Report Date: {report_data['report_date']}\n" report += f"Total Sessions: {report_data['session_count']}\n\n" report += "Latest Session Summary:\n" for key, value in latest_summary.items(): if key != "casl_metrics": report += f" {key}: {value}\n" report += "\nCASL-2 Metrics:\n" for category, value in latest_summary["casl_metrics"].items(): report += f" {category}: {value}\n" report += "\nRecommendations:\n" for rec in report_data["recommendations"]: report += f" - {rec}\n" # Save simple report if not output_path: output_path = os.path.join(self.reports_dir, f"{student_id}_report.txt") with open(output_path, 'w') as f: f.write(report) return output_path def generate_recommendations(self, sessions): """Generate recommendations based on session data""" if not sessions: return [] latest_session = sessions[-1] metrics = self.extract_casl_metrics(latest_session) recommendations = [] # Check for areas needing improvement weak_areas = [category for category, value in metrics.items() if value < 2] for area in weak_areas: if area == "lexical_semantic": recommendations.append("Focus on vocabulary building exercises such as synonyms, antonyms, and word associations") elif area == "syntactic": recommendations.append("Practice sentence formation and grammar through structured activities") elif area == "supralinguistic": recommendations.append("Work on understanding figurative language and making inferences from context") elif area == "pragmatic": recommendations.append("Engage in role-playing activities to practice social communication skills") # Add general recommendations if len(sessions) > 1: recommendations.append("Continue regular assessment sessions to track progress") if not recommendations: recommendations.append("Continue current therapy approach as all areas show adequate progress") return recommendations # This module can be used to generate reports from the session data collected by the CASL Voice Bot if __name__ == "__main__": # Example usage report_gen = CASLReportGenerator() # report_gen.generate_html_report("student123")