Spaces:
Sleeping
Sleeping
| import logging | |
| logger = logging.getLogger(__name__) | |
| logger.info("Importing PDFFeedbackGenerator.py...") | |
| from reportlab.lib.pagesizes import A4 | |
| from reportlab.pdfgen import canvas | |
| from reportlab.lib.utils import ImageReader | |
| from reportlab.lib.colors import black, yellow, Color | |
| from reportlab.pdfbase import pdfmetrics | |
| from reportlab.pdfbase.ttfonts import TTFont | |
| from reportlab.lib.styles import ParagraphStyle | |
| from reportlab.platypus import Paragraph | |
| from reportlab.lib.enums import TA_LEFT | |
| import json | |
| import re | |
| import os | |
| def wrap_text(text, max_width, canvas_obj, font_name, font_size): | |
| """Wrap text for PDF output.""" | |
| words = text.split() | |
| lines = [] | |
| current_line = "" | |
| for word in words: | |
| test_line = f"{current_line} {word}".strip() | |
| if canvas_obj.stringWidth(test_line, font_name, font_size) <= max_width: | |
| current_line = test_line | |
| else: | |
| lines.append(current_line) | |
| current_line = word | |
| if current_line: | |
| lines.append(current_line) | |
| return lines | |
| def highlight_examples(text): | |
| """Extract and format examples from text using quotes or parentheses.""" | |
| examples = [] | |
| # Match text within single quotes | |
| quote_pattern = r"'([^']+)'" | |
| examples.extend([f"'{match}'" for match in re.findall(quote_pattern, text)]) | |
| # Match text within parentheses | |
| paren_pattern = r'\(([^)]+)\)' | |
| examples.extend([f"({match})" for match in re.findall(paren_pattern, text)]) | |
| return examples | |
| class PDFFeedbackGenerator: | |
| def __init__(self, output_path, logo_path): | |
| logger.info("Initializing PDFFeedbackGenerator...") | |
| self.output_path = output_path | |
| self.logo_path = logo_path | |
| # Define colors for text and highlighting | |
| self.colors = { | |
| 'normal': black, | |
| 'highlight': Color(1, 1, 0, alpha=0.3) # Semi-transparent yellow for highlighting | |
| } | |
| # Register and define standard fonts | |
| self.register_fonts() | |
| self.fonts = { | |
| 'title': 'Helvetica-Bold', | |
| 'heading': 'Helvetica-Bold', | |
| 'normal': 'Helvetica', | |
| 'quote': 'Helvetica' | |
| } | |
| def register_fonts(self): | |
| """Register the required fonts for the PDF.""" | |
| try: | |
| # Register the basic Helvetica fonts that come with ReportLab | |
| pdfmetrics.registerFont(pdfmetrics.Font('Helvetica', 'Helvetica', 'WinAnsiEncoding')) | |
| pdfmetrics.registerFont(pdfmetrics.Font('Helvetica-Bold', 'Helvetica-Bold', 'WinAnsiEncoding')) | |
| except Exception as e: | |
| print(f"Warning: Could not register fonts: {e}") | |
| # Fallback to basic fonts if registration fails | |
| self.fonts = { | |
| 'title': 'Helvetica', | |
| 'heading': 'Helvetica', | |
| 'normal': 'Helvetica', | |
| 'quote': 'Helvetica' | |
| } | |
| def draw_highlighted_text(self, canvas_obj, text, x, y, font_name, font_size, max_width, page_height=None, margin=None, header_func=None): | |
| """Draw text with selective highlighting for quotes and parentheses, with page break support.""" | |
| words = text.split() | |
| current_line = "" | |
| current_x = x | |
| y_pos = y | |
| line_height = font_size * 1.2 | |
| # Find all highlighted segments (text in quotes or parentheses) | |
| segments = [] | |
| last_end = 0 | |
| pattern = r"'[^']+'|\([^)]+\)" | |
| for match in re.finditer(pattern, text): | |
| if last_end < match.start(): | |
| segments.append(('normal', text[last_end:match.start()])) | |
| segments.append(('highlight', match.group())) | |
| last_end = match.end() | |
| if last_end < len(text): | |
| segments.append(('normal', text[last_end:])) | |
| for segment_type, segment_text in segments: | |
| words = segment_text.split() | |
| for word in words: | |
| test_line = f"{current_line} {word}".strip() | |
| test_width = canvas_obj.stringWidth(test_line, font_name, font_size) | |
| if test_width <= max_width: | |
| current_line = test_line | |
| else: | |
| # PAGE BREAK LOGIC | |
| if page_height and margin and y_pos - line_height < margin: | |
| canvas_obj.showPage() | |
| if header_func: | |
| y_pos = header_func(canvas_obj) | |
| else: | |
| y_pos = page_height - margin | |
| current_x = x | |
| # Draw the current line with proper highlighting | |
| if current_line: | |
| if segment_type == 'highlight': | |
| text_width = canvas_obj.stringWidth(current_line, font_name, font_size) | |
| canvas_obj.setFillColor(self.colors['highlight']) | |
| canvas_obj.rect(current_x, y_pos - font_size + 2, text_width, font_size, fill=1, stroke=0) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(current_x, y_pos, current_line) | |
| y_pos -= line_height | |
| current_x = x | |
| current_line = word | |
| else: | |
| current_line = word | |
| # Draw the last line if any | |
| if current_line: | |
| if page_height and margin and y_pos - line_height < margin: | |
| canvas_obj.showPage() | |
| if header_func: | |
| y_pos = header_func(canvas_obj) | |
| else: | |
| y_pos = page_height - margin | |
| current_x = x | |
| if segment_type == 'highlight': | |
| text_width = canvas_obj.stringWidth(current_line, font_name, font_size) | |
| canvas_obj.setFillColor(self.colors['highlight']) | |
| canvas_obj.rect(current_x, y_pos - font_size + 2, text_width, font_size, fill=1, stroke=0) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(current_x, y_pos, current_line) | |
| y_pos -= line_height | |
| return y_pos | |
| def draw_color_scheme_legend(self, canvas_obj, x, y): | |
| """Removed color scheme legend as per new requirements""" | |
| pass | |
| def draw_rephrased_section(self, canvas_obj, text_analysis, x_pos, y_pos, max_width): | |
| """Draw the rephrased text section with highlights for mistakes and synonyms.""" | |
| original_y = y_pos | |
| # Section Title | |
| canvas_obj.setFont(self.fonts['heading'], 14) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(x_pos, y_pos, "Rephrased Text") | |
| y_pos -= 25 | |
| # Draw rephrased text | |
| canvas_obj.setFont(self.fonts['normal'], 12) | |
| y_pos = self.draw_highlighted_text( | |
| canvas_obj, | |
| text_analysis['rephrased_text'], | |
| x_pos, | |
| y_pos, | |
| self.fonts['normal'], | |
| 12, | |
| max_width | |
| ) | |
| y_pos -= 20 | |
| # Grammar Mistakes Section | |
| canvas_obj.setFont(self.fonts['heading'], 12) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(x_pos, y_pos, "Grammar Corrections:") | |
| y_pos -= 20 | |
| canvas_obj.setFont(self.fonts['normal'], 11) | |
| for mistake in text_analysis['grammar_mistakes']: | |
| text = f"• '{mistake['original']}' → '{mistake['correction']}'" | |
| y_pos = self.draw_highlighted_text( | |
| canvas_obj, | |
| text, | |
| x_pos + 15, | |
| y_pos, | |
| self.fonts['normal'], | |
| 11, | |
| max_width - 20 | |
| ) | |
| y_pos -= 15 | |
| # Synonyms Section | |
| canvas_obj.setFont(self.fonts['heading'], 12) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(x_pos, y_pos, "Suggested Synonyms:") | |
| y_pos -= 20 | |
| canvas_obj.setFont(self.fonts['normal'], 11) | |
| for syn in text_analysis['synonyms']: | |
| text = f"• '{syn['original']}' → {', '.join(syn['suggestions'])}" | |
| y_pos = self.draw_highlighted_text( | |
| canvas_obj, | |
| text, | |
| x_pos + 15, | |
| y_pos, | |
| self.fonts['normal'], | |
| 11, | |
| max_width - 20 | |
| ) | |
| return y_pos | |
| def draw_section_header(self, canvas_obj, text, x, y, font_name, font_size): | |
| """Draw a section header with improved styling.""" | |
| canvas_obj.setFont(font_name, font_size) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| # Draw the header text | |
| canvas_obj.drawString(x, y, text) | |
| # Draw a decorative line under the header | |
| text_width = canvas_obj.stringWidth(text, font_name, font_size) | |
| canvas_obj.setLineWidth(1.5) | |
| canvas_obj.line(x, y - 3, x + text_width, y - 3) | |
| canvas_obj.setLineWidth(1) | |
| return y - font_size - 20 # Increased spacing after header | |
| def draw_quote(self, canvas_obj, text, x, y, max_width, font_name, font_size): | |
| """Draw a quote with professional styling.""" | |
| # Draw quote background | |
| canvas_obj.setFillColor(Color(0.95, 0.97, 1.0)) | |
| quote_height = font_size * 3 # Approximate height for quote | |
| canvas_obj.rect(x - 5, y - quote_height, max_width + 10, quote_height, fill=1, stroke=0) | |
| # Draw quote text | |
| canvas_obj.setFont(font_name, font_size) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| y_pos = self.draw_highlighted_text(canvas_obj, f'"{text}"', x, y, font_name, font_size, max_width) | |
| # Draw quote decoration | |
| canvas_obj.setStrokeColor(Color(0.4, 0.6, 0.8)) | |
| # Save current line width | |
| current_line_width = canvas_obj._lineWidth | |
| # Set new line width for quote decoration | |
| canvas_obj.setLineWidth(2) | |
| canvas_obj.line(x - 5, y - quote_height/2, x - 5, y - 5) | |
| # Restore original line width | |
| canvas_obj.setLineWidth(current_line_width) | |
| return y_pos - 10 | |
| def draw_feedback_item(self, canvas_obj, text, x, y, max_width, font_name, font_size, indent=0): | |
| """Draw a feedback item with improved formatting and alignment.""" | |
| bullet = "•" | |
| if indent > 0: | |
| x += indent | |
| bullet = "◦" | |
| # Draw the bullet point with proper spacing | |
| canvas_obj.setFont(font_name, font_size) | |
| canvas_obj.drawString(x, y, bullet) | |
| # Draw the text with improved indentation and alignment | |
| text_x = x + canvas_obj.stringWidth(bullet + " ", font_name, font_size) | |
| y_pos = self.draw_highlighted_text( | |
| canvas_obj, | |
| text, | |
| text_x, | |
| y, | |
| font_name, | |
| font_size, | |
| max_width - (text_x - x) | |
| ) | |
| return y_pos - 5 # Add small spacing between items | |
| def draw_boxed_section(self, canvas_obj, x, y, width, height, fill_color=Color(0.97, 0.97, 0.97), stroke_color=Color(0.8, 0.8, 0.8)): | |
| """Draw a box (card) for a section.""" | |
| canvas_obj.saveState() | |
| # Draw the box | |
| canvas_obj.setFillColor(fill_color) | |
| canvas_obj.setStrokeColor(stroke_color) | |
| canvas_obj.setLineWidth(1) | |
| canvas_obj.roundRect(x, y - height, width, height, 8, fill=1, stroke=1) | |
| # Set up clipping using a path | |
| p = canvas_obj.beginPath() | |
| p.roundRect(x, y - height, width, height, 8) | |
| canvas_obj.clipPath(p, stroke=0, fill=0) | |
| canvas_obj.restoreState() | |
| def create_rephrased_pdf(self, user_name, question, rephrased_analysis): | |
| """Generate PDF report for rephrased text with professional formatting and layout (matching feedback PDF style).""" | |
| try: | |
| c = canvas.Canvas(self.output_path, pagesize=A4) | |
| width, height = A4 | |
| margin = 50 # Match feedback PDF margin | |
| line_height = 14 | |
| section_spacing = 20 | |
| max_width = width - 2 * margin | |
| page_number = 1 | |
| def draw_header(canvas_obj, is_first_page=False): | |
| nonlocal y_position | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| # Page number | |
| canvas_obj.setFont(self.fonts['normal'], 9) | |
| page_text = f"Page {page_number}" | |
| page_width = canvas_obj.stringWidth(page_text, self.fonts['normal'], 9) | |
| canvas_obj.drawString(width - margin - page_width, height - 25, page_text) | |
| if is_first_page: | |
| # Logo | |
| if os.path.exists(self.logo_path): | |
| try: | |
| logo = ImageReader(self.logo_path) | |
| logo_width = 60 | |
| logo_height = 60 | |
| canvas_obj.drawImage(logo, margin, height - 80, width=logo_width, height=logo_height, mask='auto') | |
| except Exception as e: | |
| print(f"Logo loading error: {e}") | |
| # Title | |
| canvas_obj.setFont(self.fonts['title'], 20) | |
| title_text = "CSS Essay Rephrased Text Report" | |
| title_width = canvas_obj.stringWidth(title_text, self.fonts['title'], 20) | |
| canvas_obj.drawString(margin + 80, height - 80, title_text) | |
| canvas_obj.setStrokeColor(self.colors['normal']) | |
| canvas_obj.setLineWidth(1.5) | |
| canvas_obj.line(margin + 80, height - 85, margin + 80 + title_width, height - 85) | |
| canvas_obj.setLineWidth(1) | |
| # Student name | |
| y_position = height - 120 | |
| canvas_obj.setFont(self.fonts['heading'], 14) | |
| canvas_obj.drawString(margin, y_position, f"Student Name: {user_name}") | |
| else: | |
| y_position = height - margin | |
| return y_position | |
| def check_new_page(y_pos, required_space): | |
| nonlocal y_position, page_number | |
| if y_pos - required_space < margin + 40: | |
| c.showPage() | |
| page_number += 1 | |
| y_position = draw_header(c, False) | |
| return True | |
| return False | |
| # Draw first page header | |
| y_position = draw_header(c, True) | |
| # Rephrased Text Section | |
| y_position -= section_spacing | |
| y_position = self.draw_section_header(c, "Rephrased Text", margin, y_position, self.fonts['heading'], 16) | |
| y_position -= 5 | |
| c.setFont(self.fonts['normal'], 12) | |
| y_position = self.draw_highlighted_text( | |
| c, | |
| rephrased_analysis['rephrased_text'], | |
| margin, | |
| y_position, | |
| self.fonts['normal'], | |
| 12, | |
| max_width - margin, | |
| page_height=height, | |
| margin=margin, | |
| header_func=lambda canv: draw_header(canv, False) | |
| ) | |
| y_position -= section_spacing | |
| # Grammar Corrections Section | |
| c.setFont(self.fonts['heading'], 12) | |
| c.drawString(margin, y_position, "Grammar Corrections:") | |
| y_position -= line_height | |
| c.setFont(self.fonts['normal'], 10) | |
| for mistake in rephrased_analysis['grammar_mistakes']: | |
| text = f"• '{mistake['original']}' → '{mistake['correction']}'" | |
| y_position = self.draw_highlighted_text( | |
| c, text, margin + 15, y_position, self.fonts['normal'], 10, max_width - 20, | |
| page_height=height, margin=margin, header_func=lambda canv: draw_header(canv, False) | |
| ) | |
| y_position -= section_spacing | |
| # Synonyms Section | |
| c.setFont(self.fonts['heading'], 12) | |
| c.drawString(margin, y_position, "Suggested Synonyms:") | |
| y_position -= line_height | |
| c.setFont(self.fonts['normal'], 10) | |
| for syn in rephrased_analysis['synonyms']: | |
| text = f"• '{syn['original']}' → {', '.join(syn['suggestions'])}" | |
| y_position = self.draw_highlighted_text( | |
| c, text, margin + 15, y_position, self.fonts['normal'], 10, max_width - 20, | |
| page_height=height, margin=margin, header_func=lambda canv: draw_header(canv, False) | |
| ) | |
| c.save() | |
| return True | |
| except Exception as e: | |
| print(f"Error generating Rephrased PDF: {str(e)}") | |
| raise | |
| def create_feedback_pdf(self, user_name, question, feedback): | |
| """Generate PDF report with the new AI Evaluation & Score structure.""" | |
| try: | |
| c = canvas.Canvas(self.output_path, pagesize=A4) | |
| width, height = A4 | |
| margin = 50 | |
| line_height = 14 | |
| section_spacing = 20 | |
| max_width = width - 2 * margin | |
| page_number = 1 | |
| def draw_header(canvas_obj, is_first_page=False): | |
| nonlocal y_position | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| # Page number | |
| canvas_obj.setFont(self.fonts['normal'], 9) | |
| page_text = f"Page {page_number}" | |
| page_width = canvas_obj.stringWidth(page_text, self.fonts['normal'], 9) | |
| canvas_obj.drawString(width - margin - page_width, height - 25, page_text) | |
| if is_first_page: | |
| # Logo | |
| if os.path.exists(self.logo_path): | |
| try: | |
| logo = ImageReader(self.logo_path) | |
| logo_width = 60 | |
| logo_height = 60 | |
| canvas_obj.drawImage(logo, margin, height - 80, width=logo_width, height=logo_height, mask='auto') | |
| except Exception as e: | |
| print(f"Logo loading error: {e}") | |
| # Title | |
| canvas_obj.setFont(self.fonts['title'], 20) | |
| title_text = "AI Evaluation & Score Report" | |
| title_width = canvas_obj.stringWidth(title_text, self.fonts['title'], 20) | |
| canvas_obj.drawString(margin + 80, height - 80, title_text) | |
| canvas_obj.setStrokeColor(self.colors['normal']) | |
| canvas_obj.setLineWidth(1.5) | |
| canvas_obj.line(margin + 80, height - 85, margin + 80 + title_width, height - 85) | |
| canvas_obj.setLineWidth(1) | |
| # Overall Score | |
| overall_score = feedback.get('overall_score', 40) | |
| canvas_obj.setFont(self.fonts['title'], 22) | |
| canvas_obj.setFillColor(Color(0.16, 0.52, 0.96)) | |
| score_text = f"Overall Essay Evaluation: {overall_score}%" | |
| canvas_obj.drawString(margin, height - 110, score_text) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| # Student name | |
| y_position = height - 140 | |
| canvas_obj.setFont(self.fonts['heading'], 14) | |
| canvas_obj.drawString(margin, y_position, f"Student Name: {user_name}") | |
| else: | |
| y_position = height - margin | |
| return y_position | |
| def check_new_page(y_pos, required_space): | |
| nonlocal y_position, page_number | |
| if y_pos - required_space < margin + 40: | |
| c.showPage() | |
| page_number += 1 | |
| y_position = draw_header(c, False) | |
| return True | |
| return False | |
| # Draw first page header | |
| y_position = draw_header(c, True) | |
| # Draw Essay Structure section after overall score | |
| essay_structure = feedback.get('essay_structure', {}) | |
| y_position -= 30 | |
| c.setFont(self.fonts['heading'], 15) | |
| c.drawString(margin, y_position, 'Essay Structure') | |
| y_position -= 20 | |
| for section, criteria in essay_structure.items(): | |
| c.setFont(self.fonts['heading'], 13) | |
| c.drawString(margin, y_position, section) | |
| y_position -= 16 | |
| for crit, result in criteria.items(): | |
| passed = result.get('value', False) | |
| explanation = result.get('explanation', '') | |
| icon = '✔' if passed else '✘' | |
| color = Color(0.16, 0.7, 0.3) if passed else Color(0.9, 0.2, 0.2) | |
| c.setFont(self.fonts['normal'], 11) | |
| c.setFillColor(color) | |
| c.drawString(margin + 15, y_position, f'{icon} {crit}') | |
| y_position -= 14 | |
| if not passed and explanation: | |
| c.setFont(self.fonts['normal'], 10) | |
| c.setFillColor(Color(0.9, 0.2, 0.2)) | |
| c.drawString(margin + 35, y_position, explanation) | |
| y_position -= 13 | |
| c.setFillColor(self.colors['normal']) | |
| y_position -= 8 | |
| # Process each feedback section (AI Evaluation & Score) | |
| for section in feedback["sections"]: | |
| if check_new_page(y_position, section_spacing + 80): | |
| pass | |
| else: | |
| y_position -= section_spacing | |
| # Draw section header | |
| c.setFont(self.fonts['heading'], 14) | |
| c.setFillColor(self.colors['normal']) | |
| heading_text = section['name'] | |
| c.drawString(margin, y_position, heading_text) | |
| text_width = c.stringWidth(heading_text, self.fonts['heading'], 14) | |
| c.setLineWidth(1.5) | |
| c.line(margin, y_position - 3, margin + text_width, y_position - 3) | |
| c.setLineWidth(1) | |
| # Draw score as percentage | |
| c.setFont(self.fonts['normal'], 12) | |
| c.drawString(margin + text_width + 20, y_position, f"Score: {section.get('score', 0)}%") | |
| y_position -= line_height + 8 | |
| # Draw number of issues | |
| num_issues = len(section.get('issues', [])) | |
| c.setFont(self.fonts['normal'], 11) | |
| c.drawString(margin, y_position, f"{num_issues} Issue{'s' if num_issues != 1 else ''}") | |
| y_position -= line_height | |
| # Draw issues (before/after) | |
| for issue in section.get('issues', []): | |
| before = issue.get('before', '') | |
| after = issue.get('after', '') | |
| c.setFont(self.fonts['normal'], 11) | |
| c.setFillColor(Color(0.9, 0.4, 0.4)) | |
| c.drawString(margin + 15, y_position, f"Before: {before}") | |
| y_position -= line_height | |
| c.setFillColor(Color(0.3, 0.6, 0.3)) | |
| c.drawString(margin + 15, y_position, f"After: {after}") | |
| y_position -= line_height + 2 | |
| c.setFillColor(self.colors['normal']) | |
| y_position -= 8 | |
| c.save() | |
| return True | |
| except Exception as e: | |
| print(f"Error generating Feedback PDF: {str(e)}") | |
| raise | |
| def wrap_text(self, text, max_width, canvas_obj, font_name, font_size): | |
| """Wrap text with error handling""" | |
| try: | |
| words = text.split() | |
| lines = [] | |
| current_line = "" | |
| for word in words: | |
| test_line = f"{current_line} {word}".strip() | |
| if canvas_obj.stringWidth(test_line, font_name, font_size) <= max_width: | |
| current_line = test_line | |
| else: | |
| lines.append(current_line) | |
| current_line = word | |
| if current_line: | |
| lines.append(current_line) | |
| return lines | |
| except Exception as e: | |
| print(f"Warning: Error in text wrapping. Using basic wrap. Error: {e}") | |
| # Fallback to basic wrapping | |
| return [text[i:i+100] for i in range(0, len(text), 100)] | |
| def draw_justified_text(self, canvas_obj, text, x, y, font_name, font_size, max_width): | |
| """Draw justified text (left and right aligned) for PDF feedback items.""" | |
| words = text.split() | |
| lines = [] | |
| current_line = [] | |
| current_width = 0 | |
| space_width = canvas_obj.stringWidth(' ', font_name, font_size) | |
| for word in words: | |
| word_width = canvas_obj.stringWidth(word, font_name, font_size) | |
| if current_width + word_width + (len(current_line) * space_width) <= max_width: | |
| current_line.append(word) | |
| current_width += word_width | |
| else: | |
| lines.append(current_line) | |
| current_line = [word] | |
| current_width = word_width | |
| if current_line: | |
| lines.append(current_line) | |
| line_height = font_size * 1.2 | |
| y_pos = y | |
| for i, line_words in enumerate(lines): | |
| if len(line_words) == 1 or i == len(lines) - 1: | |
| # Last line or single word: left align | |
| canvas_obj.drawString(x, y_pos, ' '.join(line_words)) | |
| else: | |
| total_words_width = sum(canvas_obj.stringWidth(w, font_name, font_size) for w in line_words) | |
| total_spaces = len(line_words) - 1 | |
| if total_spaces > 0: | |
| space = (max_width - total_words_width) / total_spaces | |
| else: | |
| space = space_width | |
| x_pos = x | |
| for j, word in enumerate(line_words): | |
| canvas_obj.drawString(x_pos, y_pos, word) | |
| word_width = canvas_obj.stringWidth(word, font_name, font_size) | |
| x_pos += word_width | |
| if j < len(line_words) - 1: | |
| x_pos += space | |
| y_pos -= line_height | |
| return y_pos | |
| def create_unlimited_feedback_pdf(self, user_name, question, unlimited_analysis): | |
| """ | |
| Create a comprehensive PDF report for unlimited text analysis with line-by-line feedback. | |
| """ | |
| try: | |
| # Create the PDF file | |
| canvas_obj = canvas.Canvas(self.output_path, pagesize=A4) | |
| page_width, page_height = A4 | |
| margin = 50 | |
| max_width = page_width - 2 * margin | |
| def draw_header(canvas_obj, is_first_page=False): | |
| """Draw the header for each page.""" | |
| y_pos = page_height - margin | |
| # Logo (only on first page) | |
| if is_first_page and os.path.exists(self.logo_path): | |
| try: | |
| logo = ImageReader(self.logo_path) | |
| logo_width, logo_height = logo.getSize() | |
| # Scale logo to fit | |
| scale = min(100 / logo_width, 50 / logo_height) | |
| canvas_obj.drawImage(self.logo_path, margin, y_pos - 50, | |
| logo_width * scale, logo_height * scale) | |
| except Exception as e: | |
| logger.warning(f"Could not add logo: {e}") | |
| # Title | |
| canvas_obj.setFont(self.fonts['title'], 16) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| title = "Unlimited Essay Analysis Report" | |
| canvas_obj.drawString(margin, y_pos - 30, title) | |
| # Subtitle | |
| canvas_obj.setFont(self.fonts['normal'], 12) | |
| canvas_obj.drawString(margin, y_pos - 50, f"Student: {user_name}") | |
| canvas_obj.drawString(margin, y_pos - 65, f"Question: {question}") | |
| # Processing info | |
| processing_meta = unlimited_analysis.get('processing_metadata', {}) | |
| info_text = f"Lines: {processing_meta.get('total_lines', 0)} | Words: {processing_meta.get('total_tokens', 0) * 4} | Processing: {processing_meta.get('processing_mode', 'unknown')}" | |
| canvas_obj.setFont(self.fonts['normal'], 10) | |
| canvas_obj.drawString(margin, y_pos - 80, info_text) | |
| return y_pos - 100 # Return starting y position for content | |
| def check_new_page(y_pos, required_space): | |
| """Check if we need a new page and create one if necessary.""" | |
| if y_pos - required_space < margin: | |
| canvas_obj.showPage() | |
| return draw_header(canvas_obj, is_first_page=False) | |
| return y_pos | |
| # Start with header | |
| y_pos = draw_header(canvas_obj, is_first_page=True) | |
| # Overall Analysis Section | |
| overall_analysis = unlimited_analysis.get('overall_analysis', {}) | |
| if overall_analysis and 'error' not in overall_analysis: | |
| y_pos = check_new_page(y_pos, 200) | |
| # Overall Score | |
| canvas_obj.setFont(self.fonts['heading'], 14) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(margin, y_pos, "Overall Analysis") | |
| y_pos -= 25 | |
| canvas_obj.setFont(self.fonts['normal'], 12) | |
| overall_score = overall_analysis.get('overall_score', 0) | |
| canvas_obj.drawString(margin, y_pos, f"Overall Score: {overall_score}/100") | |
| y_pos -= 20 | |
| # Category Scores | |
| category_scores = overall_analysis.get('category_scores', {}) | |
| if category_scores: | |
| canvas_obj.setFont(self.fonts['heading'], 12) | |
| canvas_obj.drawString(margin, y_pos, "Category Scores:") | |
| y_pos -= 20 | |
| canvas_obj.setFont(self.fonts['normal'], 10) | |
| for category, score in category_scores.items(): | |
| category_name = category.replace('_', ' ').title() | |
| canvas_obj.drawString(margin + 20, y_pos, f"{category_name}: {score}/100") | |
| y_pos -= 15 | |
| y_pos -= 20 | |
| # Summary Statistics Section | |
| summary_stats = unlimited_analysis.get('summary_statistics', {}) | |
| if summary_stats and 'error' not in summary_stats: | |
| y_pos = check_new_page(y_pos, 150) | |
| canvas_obj.setFont(self.fonts['heading'], 14) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(margin, y_pos, "Summary Statistics") | |
| y_pos -= 25 | |
| canvas_obj.setFont(self.fonts['normal'], 10) | |
| stats = [ | |
| f"Total Lines: {summary_stats.get('total_lines', 0)}", | |
| f"Non-empty Lines: {summary_stats.get('non_empty_lines', 0)}", | |
| f"Lines with Issues: {summary_stats.get('lines_with_issues', 0)}", | |
| f"Average Score: {summary_stats.get('average_score', 0)}" | |
| ] | |
| for stat in stats: | |
| canvas_obj.drawString(margin, y_pos, stat) | |
| y_pos -= 15 | |
| y_pos -= 20 | |
| # Line-by-Line Analysis Section | |
| line_analyses = unlimited_analysis.get('line_by_line_analysis', []) | |
| if line_analyses: | |
| y_pos = check_new_page(y_pos, 100) | |
| canvas_obj.setFont(self.fonts['heading'], 14) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(margin, y_pos, "Line-by-Line Analysis") | |
| y_pos -= 25 | |
| # Process each line analysis | |
| for line_analysis in line_analyses: | |
| line_number = line_analysis.get('line_number', 0) | |
| line_content = line_analysis.get('line_content', '') | |
| line_type = line_analysis.get('line_type', 'unknown') | |
| score = line_analysis.get('score', 0) | |
| analysis = line_analysis.get('analysis', '') | |
| # Check if we need a new page | |
| required_space = 100 # Estimate space needed | |
| y_pos = check_new_page(y_pos, required_space) | |
| # Line header | |
| canvas_obj.setFont(self.fonts['heading'], 11) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| header_text = f"Line {line_number} ({line_type}) - Score: {score}/100" | |
| canvas_obj.drawString(margin, y_pos, header_text) | |
| y_pos -= 20 | |
| # Line content | |
| canvas_obj.setFont(self.fonts['normal'], 10) | |
| if line_content.strip(): | |
| # Wrap and draw line content | |
| wrapped_content = self.wrap_text(line_content, max_width - 20, canvas_obj, self.fonts['normal'], 10) | |
| for line in wrapped_content: | |
| canvas_obj.drawString(margin + 10, y_pos, line) | |
| y_pos -= 15 | |
| y_pos -= 5 | |
| # Analysis | |
| if analysis and analysis.strip(): | |
| canvas_obj.setFont(self.fonts['normal'], 9) | |
| wrapped_analysis = self.wrap_text(analysis, max_width - 20, canvas_obj, self.fonts['normal'], 9) | |
| for line in wrapped_analysis: | |
| canvas_obj.drawString(margin + 10, y_pos, line) | |
| y_pos -= 12 | |
| # Issues | |
| issues = line_analysis.get('issues', []) | |
| if issues: | |
| y_pos -= 5 | |
| canvas_obj.setFont(self.fonts['heading'], 9) | |
| canvas_obj.drawString(margin + 10, y_pos, "Issues:") | |
| y_pos -= 15 | |
| canvas_obj.setFont(self.fonts['normal'], 8) | |
| for issue in issues[:3]: # Limit to first 3 issues per line | |
| issue_text = f"• {issue.get('description', 'Issue')}" | |
| wrapped_issue = self.wrap_text(issue_text, max_width - 30, canvas_obj, self.fonts['normal'], 8) | |
| for line in wrapped_issue: | |
| canvas_obj.drawString(margin + 20, y_pos, line) | |
| y_pos -= 10 | |
| y_pos -= 10 # Space between lines | |
| # Recommendations Section | |
| recommendations = unlimited_analysis.get('recommendations', []) | |
| if recommendations: | |
| y_pos = check_new_page(y_pos, 100) | |
| canvas_obj.setFont(self.fonts['heading'], 14) | |
| canvas_obj.setFillColor(self.colors['normal']) | |
| canvas_obj.drawString(margin, y_pos, "Recommendations") | |
| y_pos -= 25 | |
| canvas_obj.setFont(self.fonts['normal'], 10) | |
| for i, recommendation in enumerate(recommendations[:10], 1): # Limit to first 10 recommendations | |
| wrapped_rec = self.wrap_text(f"{i}. {recommendation}", max_width - 20, canvas_obj, self.fonts['normal'], 10) | |
| for line in wrapped_rec: | |
| canvas_obj.drawString(margin, y_pos, line) | |
| y_pos -= 15 | |
| y_pos -= 5 | |
| # Save the PDF | |
| canvas_obj.save() | |
| logger.info(f"Unlimited feedback PDF created: {self.output_path}") | |
| return self.output_path | |
| except Exception as e: | |
| logger.error(f"Error creating unlimited feedback PDF: {str(e)}") | |
| raise Exception(f"PDF generation failed: {str(e)}") | |
| # Example Usage | |
| if __name__ == "__main__": | |
| # Example feedback structure with the new format | |
| feedback_data = { | |
| "sections": [ | |
| { | |
| "name": "Relevance & Argumentation", | |
| "strengths": [ | |
| "Clear thesis statement addressing the main topic", | |
| "Well-supported arguments with relevant examples", | |
| "Logical flow of ideas throughout the essay" | |
| ], | |
| "improvements": [ | |
| "Could include more counterarguments", | |
| "Some points need stronger evidence", | |
| "Consider addressing opposing viewpoints" | |
| ], | |
| "suggestions": [ | |
| "Research and include at least two counterarguments", | |
| "Add more specific examples to support key points", | |
| "Strengthen the conclusion with a call to action" | |
| ], | |
| "example_quote": "The essay demonstrates a clear understanding of the topic with the statement: 'Climate change is primarily driven by human activities...'" | |
| }, | |
| # ... similar structure for other sections ... | |
| ] | |
| } | |
| generator = PDFFeedbackGenerator( | |
| output_path="feedback_report.pdf", | |
| logo_path="logo.png" | |
| ) | |
| generator.create_feedback_pdf( | |
| user_name="Jane Smith", | |
| question="Discuss the main anthropogenic factors contributing to climate change and propose feasible solutions.", | |
| feedback=feedback_data | |
| ) |