Spaces:

Code-API
/

Executor

Sleeping

App Files Files Community

Soumik Bose commited on Jan 17

Commit

1539a3f

1 Parent(s): e903858

go

Browse files

Files changed (2) hide show

pdf_report_generation_helper.py +153 -75
pdf_report_generation_service.py +440 -162

pdf_report_generation_helper.py CHANGED Viewed

@@ -1,13 +1,85 @@
 import os
 import uuid
 import logging
-import asyncio
 from typing import List, Dict, Any
 from pdf_report_generation_service import Q4ReportGenerator
-from supabase_service import upload_file_to_supabase # Assuming this exists from your previous context
 logger = logging.getLogger(__name__)
 async def generate_and_upload_report(
     config_content: List[Dict[str, Any]],
     file_name: str,
@@ -17,100 +89,106 @@ async def generate_and_upload_report(
     author: str = "AI Assistant",
     department: str = "Data Analytics",
     output_dir: str = "temp_reports",
-    confidential: bool = False
 ) -> str:
     """
     Generates a PDF report from content configuration, uploads it to Supabase,
     and returns the public URL. Cleans up temporary files afterwards.
-    """
-    # 1. Setup paths
-    os.makedirs(output_dir, exist_ok=True)
-    # Ensure filename ends with .pdf
-    if not file_name.endswith('.pdf'):
-        file_name += '.pdf'
-    # Create a unique filename to prevent collisions locally
-    unique_id = str(uuid.uuid4())[:8]
-    local_filename = f"{os.path.splitext(file_name)[0]}_{unique_id}.pdf"
-    # 2. Initialize Generator
-    generator = Q4ReportGenerator(
-        title=title,
-        subtitle=subtitle,
-        author=author,
-        department=department,
-        confidential=confidential
-    )
-    # 3. Generate PDF (Blocking I/O, so we run it in a way that doesn't block main loop if called properly)
-    # In FastAPI, we'll wrap this whole function or the generation part in run_in_threadpool
-    success = generator.generate(
-        sections=config_content,
-        filename=local_filename,
-        output_dir=output_dir,
-        cover_page=True
-    )
-    if not success:
-        raise Exception("Failed to generate PDF report locally.")
-    local_file_path = os.path.join(output_dir, local_filename)
     try:
-        # 4. Upload to Supabase
-        # We use the original desired file_name for the upload (or unique if you prefer)
-        # Using unique name in cloud storage is usually safer
         cloud_filename = f"{os.path.splitext(file_name)[0]}_{unique_id}.pdf"
-        logger.info(f"Uploading {local_file_path} to Supabase as {cloud_filename}")
-        public_url = await upload_file_to_supabase(
             file_path=local_file_path,
             file_name=cloud_filename,
             chat_id=chat_id
         )
-        logger.info(f"Upload successful. URL: {public_url}")
         return public_url
     except Exception as e:
-        logger.error(f"Failed to upload report: {e}")
-        raise e
     finally:
-        # 5. Cleanup - Delete local PDF
-        if os.path.exists(local_file_path):
-            try:
-                os.remove(local_file_path)
-                logger.info(f"Deleted local file: {local_file_path}")
-            except Exception as e:
-                logger.warning(f"Failed to delete local file {local_file_path}: {e}")
-        # 6. Cleanup - Delete downloaded images
-        # The generator class tracks images it downloaded
-        if hasattr(generator, 'downloaded_images'):
-            for img_uri in generator.downloaded_images:
-                # Convert URI back to path if needed (file://...)
-                if img_uri.startswith('file://'):
-                    img_path = img_uri[7:] # Simple strip, robust implementation depends on OS
-                    # On windows file:///C:/... might need handling
-                    if os.name == 'nt' and img_uri.startswith('file:///'):
-                        img_path = img_uri[8:]
-                    if os.path.exists(img_path):
-                        try:
-                            os.remove(img_path)
-                            logger.info(f"Deleted temp image: {img_path}")
-                        except Exception as e:
-                            logger.warning(f"Failed to delete image {img_path}: {e}")
-            # Try to remove the images directory if empty
-            images_dir = os.path.join(output_dir, 'images')
-            if os.path.exists(images_dir):
-                try:
-                    os.rmdir(images_dir)
-                except:
-                    pass

+"""
+PDF Report Generation Helper - Production Ready
+Handles PDF generation, upload to Supabase, and cleanup
+"""
 import os
 import uuid
 import logging
 from typing import List, Dict, Any
+from pathlib import Path
+from starlette.concurrency import run_in_threadpool
 from pdf_report_generation_service import Q4ReportGenerator
 logger = logging.getLogger(__name__)
+def _upload_to_supabase_sync(file_path: str, file_name: str, chat_id: str) -> str:
+    """
+    Synchronous wrapper for Supabase upload.
+    Import your actual upload function here.
+    """
+    from supabase_service import upload_file_to_supabase
+    return upload_file_to_supabase(
+        file_path=file_path,
+        file_name=file_name,
+        chat_id=chat_id
+    )
+def _generate_pdf_sync(
+    generator: Q4ReportGenerator,
+    config_content: List[Dict[str, Any]],
+    local_file_path: str,
+    output_dir: str
+) -> bool:
+    """Synchronous PDF generation wrapper"""
+    return generator.generate(
+        sections=config_content,
+        filename=os.path.basename(local_file_path),
+        output_dir=output_dir,
+        cover_page=True
+    )
+def _cleanup_files(file_paths: List[str]):
+    """Clean up temporary files"""
+    for file_path in file_paths:
+        if file_path and os.path.exists(file_path):
+            try:
+                os.remove(file_path)
+                logger.info(f"Cleaned up: {file_path}")
+            except Exception as e:
+                logger.warning(f"Failed to delete {file_path}: {e}")
+def _cleanup_downloaded_images(generator: Q4ReportGenerator, output_dir: str):
+    """Clean up images downloaded during PDF generation"""
+    if not hasattr(generator, 'downloaded_images'):
+        return
+    for img_uri in generator.downloaded_images:
+        try:
+            # Convert file:// URI to path
+            if img_uri.startswith('file://'):
+                # Handle both Unix and Windows paths
+                if os.name == 'nt' and img_uri.startswith('file:///'):
+                    img_path = img_uri[8:]  # Windows: file:///C:/...
+                else:
+                    img_path = img_uri[7:]  # Unix: file:///path/...
+                if os.path.exists(img_path):
+                    os.remove(img_path)
+                    logger.info(f"Deleted temp image: {img_path}")
+        except Exception as e:
+            logger.warning(f"Failed to delete image {img_uri}: {e}")
+    # Try to remove the images directory if empty
+    images_dir = os.path.join(output_dir, 'images')
+    if os.path.exists(images_dir):
+        try:
+            if not os.listdir(images_dir):  # Check if empty
+                os.rmdir(images_dir)
+                logger.info(f"Removed empty images directory: {images_dir}")
+        except Exception as e:
+            logger.debug(f"Could not remove images directory: {e}")
 async def generate_and_upload_report(
     config_content: List[Dict[str, Any]],
     file_name: str,
     author: str = "AI Assistant",
     department: str = "Data Analytics",
     output_dir: str = "temp_reports",
+    confidential: bool = True
 ) -> str:
     """
     Generates a PDF report from content configuration, uploads it to Supabase,
     and returns the public URL. Cleans up temporary files afterwards.
+    Args:
+        config_content: List of section dictionaries for the report
+        file_name: Desired filename (without or with .pdf extension)
+        chat_id: Chat ID for Supabase storage organization
+        title: Report title
+        subtitle: Report subtitle
+        author: Report author
+        department: Department name
+        output_dir: Directory for temporary file storage
+    Returns:
+        str: Public URL of the uploaded PDF
+    Raises:
+        Exception: If PDF generation or upload fails
+    """
+    local_file_path = None
     try:
+        # 1. Setup paths
+        os.makedirs(output_dir, exist_ok=True)
+        # Ensure filename ends with .pdf
+        if not file_name.endswith('.pdf'):
+            file_name += '.pdf'
+        # Create unique filename to prevent collisions
+        unique_id = str(uuid.uuid4())[:8]
+        local_filename = f"{os.path.splitext(file_name)[0]}_{unique_id}.pdf"
+        local_file_path = os.path.join(output_dir, local_filename)
+        logger.info(f"Starting PDF generation: {local_filename}")
+        # 2. Initialize Generator
+        generator = Q4ReportGenerator(
+            title=title,
+            subtitle=subtitle,
+            author=author,
+            department=department,
+            confidential=confidential
+        )
+        # 3. Generate PDF (Run in thread pool to avoid blocking)
+        success = await run_in_threadpool(
+            _generate_pdf_sync,
+            generator=generator,
+            config_content=config_content,
+            local_file_path=local_file_path,
+            output_dir=output_dir
+        )
+        if not success:
+            raise Exception("PDF generation failed - generator returned False")
+        if not os.path.exists(local_file_path):
+            raise Exception(f"PDF file not found after generation: {local_file_path}")
+        # 4. Upload to Supabase (Run in thread pool)
         cloud_filename = f"{os.path.splitext(file_name)[0]}_{unique_id}.pdf"
+        logger.info(f"Uploading {local_filename} to Supabase as {cloud_filename}")
+        public_url = await run_in_threadpool(
+            _upload_to_supabase_sync,
             file_path=local_file_path,
             file_name=cloud_filename,
             chat_id=chat_id
         )
+        if not public_url:
+            raise Exception("Upload failed - no URL returned")
+        logger.info(f"Upload successful: {public_url}")
         return public_url
     except Exception as e:
+        logger.error(f"Report generation/upload failed: {e}", exc_info=True)
+        raise Exception(f"Failed to generate and upload report: {str(e)}")
     finally:
+        # 5. Cleanup - Always execute, even if there's an error
+        try:
+            # Delete local PDF
+            if local_file_path:
+                _cleanup_files([local_file_path])
+            # Delete downloaded images
+            if 'generator' in locals():
+                await run_in_threadpool(
+                    _cleanup_downloaded_images,
+                    generator=generator,
+                    output_dir=output_dir
+                )
+        except Exception as cleanup_error:
+            logger.warning(f"Cleanup error (non-fatal): {cleanup_error}")

pdf_report_generation_service.py CHANGED Viewed

@@ -1,197 +1,475 @@
 """
-PDF Report Generation Helper - Production Ready
-Handles PDF generation, upload to Supabase, and cleanup
 """
 import os
-import uuid
 import logging
-from typing import List, Dict, Any
 from pathlib import Path
-from starlette.concurrency import run_in_threadpool
-from pdf_report_generation_service import Q4ReportGenerator
 logger = logging.getLogger(__name__)
-def _upload_to_supabase_sync(file_path: str, file_name: str, chat_id: str) -> str:
-    """
-    Synchronous wrapper for Supabase upload.
-    Import your actual upload function here.
-    """
-    from supabase_service import upload_file_to_supabase
-    return upload_file_to_supabase(
-        file_path=file_path,
-        file_name=file_name,
-        chat_id=chat_id
-    )
-def _generate_pdf_sync(
-    generator: Q4ReportGenerator,
-    config_content: List[Dict[str, Any]],
-    local_file_path: str,
-    output_dir: str
-) -> bool:
-    """Synchronous PDF generation wrapper"""
-    return generator.generate(
-        sections=config_content,
-        filename=os.path.basename(local_file_path),
-        output_dir=output_dir,
-        cover_page=True
-    )
-def _cleanup_files(file_paths: List[str]):
-    """Clean up temporary files"""
-    for file_path in file_paths:
-        if file_path and os.path.exists(file_path):
-            try:
-                os.remove(file_path)
-                logger.info(f"Cleaned up: {file_path}")
-            except Exception as e:
-                logger.warning(f"Failed to delete {file_path}: {e}")
-def _cleanup_downloaded_images(generator: Q4ReportGenerator, output_dir: str):
-    """Clean up images downloaded during PDF generation"""
-    if not hasattr(generator, 'downloaded_images'):
-        return
-    for img_uri in generator.downloaded_images:
-        try:
-            # Convert file:// URI to path
-            if img_uri.startswith('file://'):
-                # Handle both Unix and Windows paths
-                if os.name == 'nt' and img_uri.startswith('file:///'):
-                    img_path = img_uri[8:]  # Windows: file:///C:/...
-                else:
-                    img_path = img_uri[7:]  # Unix: file:///path/...
-                if os.path.exists(img_path):
-                    os.remove(img_path)
-                    logger.info(f"Deleted temp image: {img_path}")
-        except Exception as e:
-            logger.warning(f"Failed to delete image {img_uri}: {e}")
-    # Try to remove the images directory if empty
-    images_dir = os.path.join(output_dir, 'images')
-    if os.path.exists(images_dir):
-        try:
-            if not os.listdir(images_dir):  # Check if empty
-                os.rmdir(images_dir)
-                logger.info(f"Removed empty images directory: {images_dir}")
-        except Exception as e:
-            logger.debug(f"Could not remove images directory: {e}")
-async def generate_and_upload_report(
-    config_content: List[Dict[str, Any]],
-    file_name: str,
-    chat_id: str,
-    title: str = "Analytics Report",
-    subtitle: str = "Generated Report",
-    author: str = "AI Assistant",
-    department: str = "Data Analytics",
-    output_dir: str = "temp_reports",
-    confidential: bool = True
-) -> str:
     """
-    Generates a PDF report from content configuration, uploads it to Supabase,
-    and returns the public URL. Cleans up temporary files afterwards.
     Args:
-        config_content: List of section dictionaries for the report
-        file_name: Desired filename (without or with .pdf extension)
-        chat_id: Chat ID for Supabase storage organization
-        title: Report title
-        subtitle: Report subtitle
-        author: Report author
-        department: Department name
-        output_dir: Directory for temporary file storage
     Returns:
-        str: Public URL of the uploaded PDF
-    Raises:
-        Exception: If PDF generation or upload fails
     """
-    local_file_path = None
     try:
-        # 1. Setup paths
-        os.makedirs(output_dir, exist_ok=True)
-        # Ensure filename ends with .pdf
-        if not file_name.endswith('.pdf'):
-            file_name += '.pdf'
-        # Create unique filename to prevent collisions
-        unique_id = str(uuid.uuid4())[:8]
-        local_filename = f"{os.path.splitext(file_name)[0]}_{unique_id}.pdf"
-        local_file_path = os.path.join(output_dir, local_filename)
-        logger.info(f"Starting PDF generation: {local_filename}")
-        # 2. Initialize Generator
-        generator = Q4ReportGenerator(
-            title=title,
-            subtitle=subtitle,
-            author=author,
-            department=department,
-            confidential=confidential
-        )
-        # 3. Generate PDF (Run in thread pool to avoid blocking)
-        success = await run_in_threadpool(
-            _generate_pdf_sync,
-            generator=generator,
-            config_content=config_content,
-            local_file_path=local_file_path,
-            output_dir=output_dir
-        )
-        if not success:
-            raise Exception("PDF generation failed - generator returned False")
-        if not os.path.exists(local_file_path):
-            raise Exception(f"PDF file not found after generation: {local_file_path}")
-        # 4. Upload to Supabase (Run in thread pool)
-        cloud_filename = f"{os.path.splitext(file_name)[0]}_{unique_id}.pdf"
-        logger.info(f"Uploading {local_filename} to Supabase as {cloud_filename}")
-        public_url = await run_in_threadpool(
-            _upload_to_supabase_sync,
-            file_path=local_file_path,
-            file_name=cloud_filename,
-            chat_id=chat_id
-        )
-        if not public_url:
-            raise Exception("Upload failed - no URL returned")
-        logger.info(f"Upload successful: {public_url}")
-        return public_url
-    except Exception as e:
-        logger.error(f"Report generation/upload failed: {e}", exc_info=True)
-        raise Exception(f"Failed to generate and upload report: {str(e)}")
-    finally:
-        # 5. Cleanup - Always execute, even if there's an error
         try:
-            # Delete local PDF
-            if local_file_path:
-                _cleanup_files([local_file_path])
-            # Delete downloaded images
-            if 'generator' in locals():
-                await run_in_threadpool(
-                    _cleanup_downloaded_images,
-                    generator=generator,
-                    output_dir=output_dir
-                )
-        except Exception as cleanup_error:
-            logger.warning(f"Cleanup error (non-fatal): {cleanup_error}")
 # ---------------------------------------------------------
 # COMPLETE TEST CASE WITH FULL Q4 REPORT

 """
+Professional Q4 Report Generator - Complete Working Version
+Generates executive-quality PDF reports with proper image rendering
 """
+import markdown
+from weasyprint import HTML, CSS
+import requests
 import os
+from datetime import datetime
+from typing import List, Dict, Optional
 import logging
 from pathlib import Path
+# ---------------------------------------------------------
+# LOGGING CONFIGURATION
+# ---------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
 logger = logging.getLogger(__name__)
+# ---------------------------------------------------------
+# EXECUTIVE Q4 REPORT THEME
+# ---------------------------------------------------------
+CSS_STYLE = """
+@page {
+    size: letter;
+    margin: 0.75in 0.75in 1in 0.75in;
+    @top-center {
+        content: element(header);
+    }
+    @bottom-center {
+        content: element(footer);
+    }
+}
+body {
+    font-family: 'Helvetica', Arial, sans-serif;
+    color: #1a1a1a;
+    line-height: 1.65;
+    font-size: 11pt;
+}
+.header {
+    position: running(header);
+    font-size: 9pt;
+    color: #666;
+    border-bottom: 1px solid #ddd;
+    padding-bottom: 6px;
+    margin-bottom: 20px;
+}
+.footer {
+    position: running(footer);
+    font-size: 9pt;
+    color: #666;
+    border-top: 1px solid #ddd;
+    padding-top: 6px;
+    text-align: center;
+}
+.footer::after {
+    content: "Page " counter(page) " of " counter(pages);
+}
+.confidential-mark {
+    color: #d32f2f;
+    font-weight: bold;
+    float: left;
+}
+.cover-page {
+    text-align: center;
+    padding-top: 3in;
+    page-break-after: always;
+}
+.cover-title {
+    font-size: 36pt;
+    font-weight: bold;
+    color: #003366;
+    margin-bottom: 0.5in;
+    letter-spacing: 1px;
+    line-height: 1.2;
+}
+.cover-subtitle {
+    font-size: 20pt;
+    color: #0055a5;
+    margin-bottom: 1.2in;
+    font-weight: 500;
+}
+.cover-meta {
+    font-size: 15pt;
+    color: #555;
+    margin-bottom: 0.25in;
+    line-height: 1.5;
+}
+.cover-date {
+    font-size: 12pt;
+    color: #888;
+    margin-top: 0.5in;
+}
+.cover-divider {
+    width: 3in;
+    height: 3px;
+    background: linear-gradient(to right, #003366, #0055a5);
+    margin: 0.5in auto;
+}
+h1 {
+    color: #003366;
+    font-size: 20pt;
+    border-bottom: 3px solid #0055a5;
+    padding-bottom: 10px;
+    margin-top: 28px;
+    margin-bottom: 18px;
+    page-break-after: avoid;
+    font-weight: bold;
+}
+h2 {
+    color: #0055a5;
+    font-size: 15pt;
+    margin-top: 22px;
+    margin-bottom: 14px;
+    page-break-after: avoid;
+    font-weight: 600;
+}
+h3 {
+    color: #333;
+    font-size: 13pt;
+    margin-top: 18px;
+    margin-bottom: 12px;
+    page-break-after: avoid;
+    font-weight: 600;
+}
+table {
+    width: 100%;
+    border-collapse: collapse;
+    margin: 18px 0;
+    font-size: 10pt;
+    page-break-inside: avoid;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+}
+thead {
+    background: linear-gradient(to bottom, #003366, #00264d);
+}
+th {
+    background-color: #003366;
+    color: white;
+    padding: 12px;
+    text-align: left;
+    font-weight: bold;
+    border: 1px solid #002244;
+    font-size: 10.5pt;
+}
+td {
+    padding: 10px 12px;
+    border: 1px solid #ddd;
+    line-height: 1.5;
+}
+tr:nth-child(even) {
+    background-color: #f8f9fa;
+}
+tr:nth-child(odd) {
+    background-color: #ffffff;
+}
+.highlight-box {
+    background-color: #e8f4f8;
+    border-left: 5px solid #0055a5;
+    padding: 16px 20px;
+    margin: 20px 0;
+    page-break-inside: avoid;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+}
+.key-metric-box {
+    background: linear-gradient(135deg, #003366 0%, #0055a5 100%);
+    color: white;
+    border-radius: 8px;
+    padding: 18px 22px;
+    margin: 20px 0;
+    page-break-inside: avoid;
+    box-shadow: 0 3px 6px rgba(0,0,0,0.15);
+}
+.key-metric-box h3 {
+    color: white;
+    margin-top: 0;
+}
+blockquote {
+    border-left: 5px solid #003366;
+    margin-left: 0;
+    padding-left: 20px;
+    color: #333;
+    font-style: italic;
+    background-color: #f8f9fa;
+    padding: 14px 14px 14px 20px;
+    margin: 18px 0;
+    box-shadow: 0 1px 2px rgba(0,0,0,0.05);
+}
+.figure-container {
+    text-align: center;
+    margin: 24px 0;
+    page-break-inside: avoid;
+}
+.figure-container img {
+    max-width: 100%;
+    height: auto;
+    border: 1px solid #ddd;
+    padding: 8px;
+    background: white;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+.figure-caption {
+    font-size: 9.5pt;
+    color: #666;
+    margin-top: 10px;
+    font-style: italic;
+    font-weight: 500;
+}
+.executive-summary {
+    background-color: #f0f7ff;
+    border: 2px solid #0055a5;
+    padding: 20px;
+    margin: 24px 0;
+    page-break-inside: avoid;
+    border-radius: 5px;
+}
+.page-break {
+    page-break-after: always;
+}
+ul, ol {
+    margin: 14px 0;
+    padding-left: 28px;
+}
+li {
+    margin: 8px 0;
+    line-height: 1.6;
+}
+strong {
+    font-weight: 600;
+    color: #000;
+}
+"""
+# ---------------------------------------------------------
+# IMAGE HANDLING
+# ---------------------------------------------------------
+def fetch_image(url: str, output_dir: str) -> Optional[str]:
     """
+    Download image from URL to persistent file for PDF rendering.
     Args:
+        url: The URL of the image
+        output_dir: Directory to save downloaded images
     Returns:
+        File URI string or None if failed
     """
+    if not url.startswith(('http://', 'https://')):
+        if os.path.exists(url):
+            abs_path = os.path.abspath(url)
+            return Path(abs_path).as_uri()
+        return None
     try:
+        img_dir = os.path.join(output_dir, 'images')
+        os.makedirs(img_dir, exist_ok=True)
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+        response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()
+        # Determine file extension
+        content_type = response.headers.get('content-type', '')
+        ext = '.jpg'
+        if 'png' in content_type:
+            ext = '.png'
+        elif 'gif' in content_type:
+            ext = '.gif'
+        elif 'svg' in content_type:
+            ext = '.svg'
+        elif 'webp' in content_type:
+            ext = '.webp'
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S_%f')
+        filename = f'img_{timestamp}{ext}'
+        filepath = os.path.join(img_dir, filename)
+        with open(filepath, 'wb') as f:
+            f.write(response.content)
+        abs_path = os.path.abspath(filepath)
+        file_uri = Path(abs_path).as_uri()
+        logger.info(f"Downloaded image: {url[:50]}... -> {filename}")
+        return file_uri
+    except Exception as e:
+        logger.warning(f"Failed to download image: {url[:50]}... - {e}")
+        return None
+# ---------------------------------------------------------
+# Q4 REPORT GENERATOR CLASS
+# ---------------------------------------------------------
+class Q4ReportGenerator:
+    """Generates executive-quality Q4 reports using WeasyPrint."""
+    def __init__(self,
+                 title: str = "Q4 Performance Report",
+                 subtitle: str = None,
+                 author: str = None,
+                 department: str = None,
+                 date: str = None,
+                 header_text: str = None,
+                 confidential: bool = True):
+        self.title = title
+        self.subtitle = subtitle or "Fourth Quarter Analysis"
+        self.author = author or "Data Analytics Team"
+        self.department = department or "Analytics Department"
+        self.date = date or datetime.now().strftime("%B %d, %Y")
+        self.confidential = confidential
+        self.downloaded_images = []
+        if header_text:
+            self.header_text = header_text
+        else:
+            parts = [self.department, self.subtitle]
+            self.header_text = " | ".join(parts)
+    def _build_header(self) -> str:
+        return f'<div class="header">{self.header_text}</div>'
+    def _build_footer(self) -> str:
+        footer_html = '<div class="footer">'
+        if self.confidential:
+            footer_html += '<span class="confidential-mark">CONFIDENTIAL</span>'
+        footer_html += '</div>'
+        return footer_html
+    def _build_cover_page(self) -> str:
+        return f"""
+        <div class="cover-page">
+            <div class="cover-title">{self.title}</div>
+            <div class="cover-divider"></div>
+            <div class="cover-subtitle">{self.subtitle}</div>
+            <div class="cover-meta">{self.department}</div>
+            <div class="cover-meta">Prepared by: {self.author}</div>
+            <div class="cover-date">{self.date}</div>
+        </div>
+        """
+    def _process_section(self, section: Dict, output_dir: str) -> str:
+        html = ""
+        content = section.get("content", "")
+        if content:
+            html_content = markdown.markdown(
+                content,
+                extensions=['extra', 'sane_lists', 'tables', 'fenced_code']
+            )
+            html += f"<div class='section'>{html_content}</div>"
+        images = section.get("images", [])
+        for img_data in images:
+            if isinstance(img_data, dict):
+                img_url = img_data.get("url", "")
+                caption = img_data.get("caption", "Figure: Visualization")
+            else:
+                img_url = img_data
+                caption = "Figure: Visualization"
+            if img_url:
+                file_uri = fetch_image(img_url, output_dir)
+                if file_uri:
+                    self.downloaded_images.append(file_uri)
+                    html += f"""
+                    <div class="figure-container">
+                        <img src="{file_uri}" alt="{caption}">
+                        <div class="figure-caption">{caption}</div>
+                    </div>
+                    """
+        if section.get("page_break", False):
+            html += '<div class="page-break"></div>'
+        return html
+    def generate(self,
+                 sections: List[Dict],
+                 filename: str = "Q4_Report.pdf",
+                 output_dir: str = "./output",
+                 cover_page: bool = True) -> bool:
         try:
+            os.makedirs(output_dir, exist_ok=True)
+            output_path = os.path.join(output_dir, filename)
+            logger.info(f"Starting Q4 report generation: {output_path}")
+            body_html = ""
+            if cover_page:
+                body_html += self._build_cover_page()
+            for idx, section in enumerate(sections):
+                logger.info(f"Processing section {idx + 1}/{len(sections)}")
+                body_html += self._process_section(section, output_dir)
+            full_html = f"""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <title>{self.title}</title>
+            </head>
+            <body>
+                {self._build_header()}
+                {self._build_footer()}
+                {body_html}
+            </body>
+            </html>
+            """
+            logger.info("Rendering PDF with WeasyPrint...")
+            html_doc = HTML(string=full_html)
+            css_doc = CSS(string=CSS_STYLE)
+            html_doc.write_pdf(output_path, stylesheets=[css_doc])
+            abs_path = os.path.abspath(output_path)
+            file_size = os.path.getsize(output_path) / 1024
+            print(f"\n{'='*70}")
+            print(f"✅ PDF GENERATED SUCCESSFULLY!")
+            print(f"{'='*70}")
+            print(f"📁 Location: {abs_path}")
+            print(f"📊 Size: {file_size:.2f} KB")
+            print(f"🖼️  Images: {len(self.downloaded_images)} embedded")
+            print(f"{'='*70}\n")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error generating report: {e}", exc_info=True)
+            return False
 # ---------------------------------------------------------
 # COMPLETE TEST CASE WITH FULL Q4 REPORT