454 lines
20 KiB
Python
454 lines
20 KiB
Python
"""
|
|
HTML renderer for report generation.
|
|
"""
|
|
|
|
from .rendererBaseTemplate import BaseRenderer
|
|
from typing import Dict, Any, Tuple, List
|
|
|
|
class RendererHtml(BaseRenderer):
|
|
"""Renders content to HTML format with format-specific extraction."""
|
|
|
|
@classmethod
|
|
def getSupportedFormats(cls) -> List[str]:
|
|
"""Return supported HTML formats."""
|
|
return ['html', 'htm']
|
|
|
|
@classmethod
|
|
def getFormatAliases(cls) -> List[str]:
|
|
"""Return format aliases."""
|
|
return ['web', 'webpage']
|
|
|
|
@classmethod
|
|
def getPriority(cls) -> int:
|
|
"""Return priority for HTML renderer."""
|
|
return 100
|
|
|
|
async def render(self, extractedContent: Dict[str, Any], title: str, userPrompt: str = None, aiService=None) -> Tuple[str, str]:
|
|
"""Render extracted JSON content to HTML format using AI-analyzed styling."""
|
|
try:
|
|
# Generate HTML using AI-analyzed styling
|
|
htmlContent = await self._generateHtmlFromJson(extractedContent, title, userPrompt, aiService)
|
|
|
|
return htmlContent, "text/html"
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error rendering HTML: {str(e)}")
|
|
# Return minimal HTML fallback
|
|
return f"<html><head><title>{title}</title></head><body><h1>{title}</h1><p>Error rendering report: {str(e)}</p></body></html>", "text/html"
|
|
|
|
async def _generateHtmlFromJson(self, jsonContent: Dict[str, Any], title: str, userPrompt: str = None, aiService=None) -> str:
|
|
"""Generate HTML content from structured JSON document using AI-generated styling."""
|
|
try:
|
|
# Get style set: default styles, enhanced with AI if userPrompt provided
|
|
styles = await self._getStyleSet(userPrompt, aiService)
|
|
|
|
# Validate JSON structure
|
|
if not isinstance(jsonContent, dict):
|
|
raise ValueError("JSON content must be a dictionary")
|
|
|
|
if "sections" not in jsonContent:
|
|
raise ValueError("JSON content must contain 'sections' field")
|
|
|
|
# Use title from JSON metadata if available, otherwise use provided title
|
|
documentTitle = jsonContent.get("metadata", {}).get("title", title)
|
|
|
|
# Build HTML document
|
|
htmlParts = []
|
|
|
|
# HTML document structure
|
|
htmlParts.append('<!DOCTYPE html>')
|
|
htmlParts.append('<html lang="en">')
|
|
htmlParts.append('<head>')
|
|
htmlParts.append('<meta charset="UTF-8">')
|
|
htmlParts.append('<meta name="viewport" content="width=device-width, initial-scale=1.0">')
|
|
htmlParts.append(f'<title>{documentTitle}</title>')
|
|
htmlParts.append('<style>')
|
|
htmlParts.append(self._generateCssStyles(styles))
|
|
htmlParts.append('</style>')
|
|
htmlParts.append('</head>')
|
|
htmlParts.append('<body>')
|
|
|
|
# Document header
|
|
htmlParts.append(f'<header><h1 class="document-title">{documentTitle}</h1></header>')
|
|
|
|
# Main content
|
|
htmlParts.append('<main>')
|
|
|
|
# Process each section
|
|
sections = jsonContent.get("sections", [])
|
|
for section in sections:
|
|
sectionHtml = self._renderJsonSection(section, styles)
|
|
if sectionHtml:
|
|
htmlParts.append(sectionHtml)
|
|
|
|
htmlParts.append('</main>')
|
|
|
|
# Footer
|
|
htmlParts.append('<footer>')
|
|
htmlParts.append(f'<p class="generated-info">Generated: {self._formatTimestamp()}</p>')
|
|
htmlParts.append('</footer>')
|
|
|
|
htmlParts.append('</body>')
|
|
htmlParts.append('</html>')
|
|
|
|
return '\n'.join(htmlParts)
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error generating HTML from JSON: {str(e)}")
|
|
raise Exception(f"HTML generation failed: {str(e)}")
|
|
|
|
async def _getStyleSet(self, userPrompt: str = None, aiService=None, templateName: str = None) -> Dict[str, Any]:
|
|
"""Get style set - default styles, enhanced with AI if userPrompt provided.
|
|
|
|
Args:
|
|
userPrompt: User's prompt (AI will detect style instructions in any language)
|
|
aiService: AI service (used only if userPrompt provided)
|
|
templateName: Name of template style set (None = default)
|
|
|
|
Returns:
|
|
Dict with style definitions for all document styles
|
|
"""
|
|
# Get default style set
|
|
defaultStyleSet = self._getDefaultStyleSet()
|
|
|
|
# Enhance with AI if userPrompt provided (AI handles multilingual style detection)
|
|
if userPrompt and aiService:
|
|
# AI will naturally detect style instructions in any language
|
|
self.logger.info(f"Enhancing styles with AI based on user prompt...")
|
|
enhancedStyleSet = await self._enhanceStylesWithAI(userPrompt, defaultStyleSet, aiService)
|
|
return self._validateStylesContrast(enhancedStyleSet)
|
|
else:
|
|
# Use default styles only
|
|
return defaultStyleSet
|
|
|
|
async def _enhanceStylesWithAI(self, userPrompt: str, defaultStyleSet: Dict[str, Any], aiService) -> Dict[str, Any]:
|
|
"""Enhance default styles with AI based on user prompt."""
|
|
try:
|
|
style_template = self._createAiStyleTemplate("html", userPrompt, defaultStyleSet)
|
|
enhanced_styles = await self._getAiStyles(aiService, style_template, defaultStyleSet)
|
|
return enhanced_styles
|
|
except Exception as e:
|
|
self.logger.warning(f"AI style enhancement failed: {str(e)}, using default styles")
|
|
return defaultStyleSet
|
|
|
|
def _validateStylesContrast(self, styles: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Validate and fix contrast issues in AI-generated styles."""
|
|
try:
|
|
# Fix table header contrast
|
|
if "table_header" in styles:
|
|
header = styles["table_header"]
|
|
bgColor = header.get("background", "#FFFFFF")
|
|
textColor = header.get("color", "#000000")
|
|
|
|
# If both are white or both are dark, fix it
|
|
if bgColor.upper() == "#FFFFFF" and textColor.upper() == "#FFFFFF":
|
|
header["background"] = "#4F4F4F"
|
|
header["color"] = "#FFFFFF"
|
|
elif bgColor.upper() == "#000000" and textColor.upper() == "#000000":
|
|
header["background"] = "#4F4F4F"
|
|
header["color"] = "#FFFFFF"
|
|
|
|
# Fix table cell contrast
|
|
if "table_cell" in styles:
|
|
cell = styles["table_cell"]
|
|
bgColor = cell.get("background", "#FFFFFF")
|
|
textColor = cell.get("color", "#000000")
|
|
|
|
# If both are white or both are dark, fix it
|
|
if bgColor.upper() == "#FFFFFF" and textColor.upper() == "#FFFFFF":
|
|
cell["background"] = "#FFFFFF"
|
|
cell["color"] = "#2F2F2F"
|
|
elif bgColor.upper() == "#000000" and textColor.upper() == "#000000":
|
|
cell["background"] = "#FFFFFF"
|
|
cell["color"] = "#2F2F2F"
|
|
|
|
return styles
|
|
|
|
except Exception as e:
|
|
self.logger.warning(f"Style validation failed: {str(e)}")
|
|
return self._getDefaultStyleSet()
|
|
|
|
def _getDefaultStyleSet(self) -> Dict[str, Any]:
|
|
"""Default HTML style set - used when no style instructions present."""
|
|
return {
|
|
"title": {"font_size": "2.5em", "color": "#1F4E79", "font_weight": "bold", "text_align": "center", "margin": "0 0 1em 0"},
|
|
"heading1": {"font_size": "2em", "color": "#2F2F2F", "font_weight": "bold", "text_align": "left", "margin": "1.5em 0 0.5em 0"},
|
|
"heading2": {"font_size": "1.5em", "color": "#4F4F4F", "font_weight": "bold", "text_align": "left", "margin": "1em 0 0.5em 0"},
|
|
"paragraph": {"font_size": "1em", "color": "#2F2F2F", "font_weight": "normal", "text_align": "left", "margin": "0 0 1em 0", "line_height": "1.6"},
|
|
"table": {"border": "1px solid #ddd", "border_collapse": "collapse", "width": "100%", "margin": "1em 0"},
|
|
"table_header": {"background": "#4F4F4F", "color": "#FFFFFF", "font_weight": "bold", "text_align": "center", "padding": "12px"},
|
|
"table_cell": {"background": "#FFFFFF", "color": "#2F2F2F", "font_weight": "normal", "text_align": "left", "padding": "8px", "border": "1px solid #ddd"},
|
|
"bullet_list": {"font_size": "1em", "color": "#2F2F2F", "margin": "0 0 1em 0", "padding_left": "20px"},
|
|
"code_block": {"font_family": "Courier New, monospace", "font_size": "0.9em", "color": "#2F2F2F", "background": "#F5F5F5", "padding": "1em", "border": "1px solid #ddd", "border_radius": "4px", "margin": "1em 0"},
|
|
"image": {"max_width": "100%", "height": "auto", "margin": "1em 0", "border_radius": "4px"},
|
|
"body": {"font_family": "Arial, sans-serif", "background": "#FFFFFF", "color": "#2F2F2F", "margin": "0", "padding": "20px"}
|
|
}
|
|
|
|
|
|
def _generateCssStyles(self, styles: Dict[str, Any]) -> str:
|
|
"""Generate CSS from style definitions."""
|
|
css_parts = []
|
|
|
|
# Body styles
|
|
body_style = styles.get("body", {})
|
|
css_parts.append("body {")
|
|
for property_name, value in body_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Document title
|
|
title_style = styles.get("title", {})
|
|
css_parts.append(".document-title {")
|
|
for property_name, value in title_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Headings
|
|
for heading_level in ["heading1", "heading2"]:
|
|
heading_style = styles.get(heading_level, {})
|
|
css_class = f"h{heading_level[-1]}"
|
|
css_parts.append(f"{css_class} {{")
|
|
for property_name, value in heading_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Paragraphs
|
|
paragraph_style = styles.get("paragraph", {})
|
|
css_parts.append("p {")
|
|
for property_name, value in paragraph_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Tables
|
|
table_style = styles.get("table", {})
|
|
css_parts.append("table {")
|
|
for property_name, value in table_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Table headers
|
|
table_header_style = styles.get("table_header", {})
|
|
css_parts.append("th {")
|
|
for property_name, value in table_header_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Table cells
|
|
table_cell_style = styles.get("table_cell", {})
|
|
css_parts.append("td {")
|
|
for property_name, value in table_cell_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Lists
|
|
bullet_list_style = styles.get("bullet_list", {})
|
|
css_parts.append("ul {")
|
|
for property_name, value in bullet_list_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Code blocks
|
|
code_block_style = styles.get("code_block", {})
|
|
css_parts.append("pre {")
|
|
for property_name, value in code_block_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Images
|
|
image_style = styles.get("image", {})
|
|
css_parts.append("img {")
|
|
for property_name, value in image_style.items():
|
|
css_property = property_name.replace("_", "-")
|
|
css_parts.append(f" {css_property}: {value};")
|
|
css_parts.append("}")
|
|
|
|
# Generated info
|
|
css_parts.append(".generated-info {")
|
|
css_parts.append(" font-size: 0.9em;")
|
|
css_parts.append(" color: #666;")
|
|
css_parts.append(" text-align: center;")
|
|
css_parts.append(" margin-top: 2em;")
|
|
css_parts.append(" padding-top: 1em;")
|
|
css_parts.append(" border-top: 1px solid #ddd;")
|
|
css_parts.append("}")
|
|
|
|
return '\n'.join(css_parts)
|
|
|
|
def _renderJsonSection(self, section: Dict[str, Any], styles: Dict[str, Any]) -> str:
|
|
"""Render a single JSON section to HTML using AI-generated styles."""
|
|
try:
|
|
sectionType = self._getSectionType(section)
|
|
sectionData = self._getSectionData(section)
|
|
|
|
if sectionType == "table":
|
|
# Process the section data to extract table structure
|
|
processedData = self._processSectionByType(section)
|
|
return self._renderJsonTable(processedData, styles)
|
|
elif sectionType == "bullet_list":
|
|
# Process the section data to extract bullet list structure
|
|
processedData = self._processSectionByType(section)
|
|
return self._renderJsonBulletList(processedData, styles)
|
|
elif sectionType == "heading":
|
|
return self._renderJsonHeading(sectionData, styles)
|
|
elif sectionType == "paragraph":
|
|
return self._renderJsonParagraph(sectionData, styles)
|
|
elif sectionType == "code_block":
|
|
# Process the section data to extract code block structure
|
|
processedData = self._processSectionByType(section)
|
|
return self._renderJsonCodeBlock(processedData, styles)
|
|
elif sectionType == "image":
|
|
# Process the section data to extract image structure
|
|
processedData = self._processSectionByType(section)
|
|
return self._renderJsonImage(processedData, styles)
|
|
else:
|
|
# Fallback to paragraph for unknown types
|
|
return self._renderJsonParagraph(sectionData, styles)
|
|
|
|
except Exception as e:
|
|
self.logger.warning(f"Error rendering section {self._getSectionId(section)}: {str(e)}")
|
|
return f'<div class="error">[Error rendering section: {str(e)}]</div>'
|
|
|
|
def _renderJsonTable(self, tableData: Dict[str, Any], styles: Dict[str, Any]) -> str:
|
|
"""Render a JSON table to HTML using AI-generated styles."""
|
|
try:
|
|
headers = tableData.get("headers", [])
|
|
rows = tableData.get("rows", [])
|
|
|
|
if not headers or not rows:
|
|
return ""
|
|
|
|
htmlParts = ['<table>']
|
|
|
|
# Table header
|
|
htmlParts.append('<thead><tr>')
|
|
for header in headers:
|
|
htmlParts.append(f'<th>{header}</th>')
|
|
htmlParts.append('</tr></thead>')
|
|
|
|
# Table body
|
|
htmlParts.append('<tbody>')
|
|
for row in rows:
|
|
htmlParts.append('<tr>')
|
|
for cellData in row:
|
|
htmlParts.append(f'<td>{cellData}</td>')
|
|
htmlParts.append('</tr>')
|
|
htmlParts.append('</tbody>')
|
|
|
|
htmlParts.append('</table>')
|
|
return '\n'.join(htmlParts)
|
|
|
|
except Exception as e:
|
|
self.logger.warning(f"Error rendering table: {str(e)}")
|
|
return ""
|
|
|
|
def _renderJsonBulletList(self, listData: Dict[str, Any], styles: Dict[str, Any]) -> str:
|
|
"""Render a JSON bullet list to HTML using AI-generated styles."""
|
|
try:
|
|
items = listData.get("items", [])
|
|
|
|
if not items:
|
|
return ""
|
|
|
|
htmlParts = ['<ul>']
|
|
for item in items:
|
|
if isinstance(item, str):
|
|
htmlParts.append(f'<li>{item}</li>')
|
|
elif isinstance(item, dict) and "text" in item:
|
|
htmlParts.append(f'<li>{item["text"]}</li>')
|
|
htmlParts.append('</ul>')
|
|
|
|
return '\n'.join(htmlParts)
|
|
|
|
except Exception as e:
|
|
self.logger.warning(f"Error rendering bullet list: {str(e)}")
|
|
return ""
|
|
|
|
def _renderJsonHeading(self, headingData: Dict[str, Any], styles: Dict[str, Any]) -> str:
|
|
"""Render a JSON heading to HTML using AI-generated styles."""
|
|
try:
|
|
# Normalize non-dict inputs
|
|
if isinstance(headingData, str):
|
|
headingData = {"text": headingData, "level": 2}
|
|
elif isinstance(headingData, list):
|
|
# Render a list as bullet list under a default heading label
|
|
return self._renderJsonBulletList({"items": headingData}, styles)
|
|
elif not isinstance(headingData, dict):
|
|
return ""
|
|
|
|
level = headingData.get("level", 1)
|
|
text = headingData.get("text", "")
|
|
|
|
if text:
|
|
level = max(1, min(6, level))
|
|
return f'<h{level}>{text}</h{level}>'
|
|
|
|
return ""
|
|
|
|
except Exception as e:
|
|
self.logger.warning(f"Error rendering heading: {str(e)}")
|
|
return ""
|
|
|
|
def _renderJsonParagraph(self, paragraphData: Dict[str, Any], styles: Dict[str, Any]) -> str:
|
|
"""Render a JSON paragraph to HTML using AI-generated styles."""
|
|
try:
|
|
# Normalize non-dict inputs
|
|
if isinstance(paragraphData, str):
|
|
paragraphData = {"text": paragraphData}
|
|
elif isinstance(paragraphData, list):
|
|
# Treat list as bullet list paragraph
|
|
return self._renderJsonBulletList({"items": paragraphData}, styles)
|
|
elif not isinstance(paragraphData, dict):
|
|
return ""
|
|
|
|
text = paragraphData.get("text", "")
|
|
|
|
if text:
|
|
return f'<p>{text}</p>'
|
|
|
|
return ""
|
|
|
|
except Exception as e:
|
|
self.logger.warning(f"Error rendering paragraph: {str(e)}")
|
|
return ""
|
|
|
|
def _renderJsonCodeBlock(self, codeData: Dict[str, Any], styles: Dict[str, Any]) -> str:
|
|
"""Render a JSON code block to HTML using AI-generated styles."""
|
|
try:
|
|
code = codeData.get("code", "")
|
|
language = codeData.get("language", "")
|
|
|
|
if code:
|
|
if language:
|
|
return f'<pre><code class="language-{language}">{code}</code></pre>'
|
|
else:
|
|
return f'<pre><code>{code}</code></pre>'
|
|
|
|
return ""
|
|
|
|
except Exception as e:
|
|
self.logger.warning(f"Error rendering code block: {str(e)}")
|
|
return ""
|
|
|
|
def _renderJsonImage(self, imageData: Dict[str, Any], styles: Dict[str, Any]) -> str:
|
|
"""Render a JSON image to HTML."""
|
|
try:
|
|
base64Data = imageData.get("base64Data", "")
|
|
altText = imageData.get("altText", "Image")
|
|
|
|
if base64Data:
|
|
return f'<img src="data:image/png;base64,{base64Data}" alt="{altText}">'
|
|
|
|
return ""
|
|
|
|
except Exception as e:
|
|
self.logger.warning(f"Error rendering image: {str(e)}")
|
|
return f'<div class="error">[Image: {imageData.get("altText", "Image")}]</div>'
|