go

controller.py

@@ -780,21 +780,35 @@ async def get_chat_log_endpoint(payload: ChatLogRequest, token: str = Depends(va
 @app.post("/api/generate_pdf_report", response_model=ReportGenerationResponse)
 async def generate_pdf_report_endpoint(
     payload: ReportGenerationRequest, 
-    token: str = Depends(validate_token) # Assuming validate_token is defined in your main file
+    token: str = Depends(validate_token)
 ):
     """
-    Generates a PDF report, uploads it to Supabase via the helper, 
-    and returns the public URL.
+    Generates a PDF report, uploads it to Supabase, and returns the public URL.
+    
+    This endpoint:
+    1. Validates the request payload
+    2. Converts Pydantic models to dictionaries
+    3. Generates the PDF with proper formatting
+    4. Uploads to Supabase storage
+    5. Cleans up temporary files
+    6. Returns the public URL
     """
     request_id = str(uuid.uuid4())[:8]
     
     try:
-        # Convert Pydantic models to a list of dictionaries for the helper
-        # .model_dump() is for Pydantic v2, use .dict() for v1
-        config_content = [section.dict() for section in payload.sections]
+        logger.info(f"[{request_id}] Starting PDF report generation for chat: {payload.chat_id}")
+        
+        # Convert Pydantic models to dictionaries for the generator
+        # Use .model_dump() for Pydantic v2, .dict() for v1
+        try:
+            config_content = [section.model_dump() for section in payload.sections]
+        except AttributeError:
+            # Fallback for Pydantic v1
+            config_content = [section.dict() for section in payload.sections]
+        
+        logger.info(f"[{request_id}] Processing {len(config_content)} sections")
         
-        # Call the helper function directly.
-        # It handles generation, upload, and cleanup.
+        # Call the async helper function
         public_url = await generate_and_upload_report(
             config_content=config_content,
             file_name=payload.file_name,
@@ -806,15 +820,22 @@ async def generate_pdf_report_endpoint(
             output_dir="temp_reports"
         )
         
+        # Prepare final filename
+        final_filename = payload.file_name
+        if not final_filename.endswith('.pdf'):
+            final_filename += '.pdf'
+        
+        logger.info(f"[{request_id}] Report generated successfully: {public_url}")
+        
         return ReportGenerationResponse(
             success=True,
             pdf_report_file_url=public_url,
-            file_name=f"{payload.file_name}.pdf" if not payload.file_name.endswith('.pdf') else payload.file_name,
+            file_name=final_filename,
             request_id=request_id
         )
-
+        
     except Exception as e:
-        logger.error(f"Report Generation Failed: {e}")
+        logger.error(f"[{request_id}] Report generation failed: {e}", exc_info=True)
         return ReportGenerationResponse(
             success=False,
             error=str(e),

pdf_report_generation_service.py

@@ -1,475 +1,196 @@
 """
-Professional Q4 Report Generator - Complete Working Version
-Generates executive-quality PDF reports with proper image rendering
+PDF Report Generation Helper - Production Ready
+Handles PDF generation, upload to Supabase, and cleanup
 """
-import markdown
-from weasyprint import HTML, CSS
-import requests
 import os
-from datetime import datetime
-from typing import List, Dict, Optional
+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
 
-# ---------------------------------------------------------
-# 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;
+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
     
-    @top-center {
-        content: element(header);
-    }
+    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}")
     
-    @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]:
+    # 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"
+) -> str:
     """
-    Download image from URL to persistent file for PDF rendering.
+    Generates a PDF report from content configuration, uploads it to Supabase,
+    and returns the public URL. Cleans up temporary files afterwards.
     
     Args:
-        url: The URL of the image
-        output_dir: Directory to save downloaded images
+        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:
-        File URI string or None if failed
+        str: Public URL of the uploaded PDF
+        
+    Raises:
+        Exception: If PDF generation or upload fails
     """
-    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
+    
+    local_file_path = None
     
     try:
-        img_dir = os.path.join(output_dir, 'images')
-        os.makedirs(img_dir, exist_ok=True)
+        # 1. Setup paths
+        os.makedirs(output_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()
+        # Ensure filename ends with .pdf
+        if not file_name.endswith('.pdf'):
+            file_name += '.pdf'
         
-        # 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'
+        # 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)
         
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S_%f')
-        filename = f'img_{timestamp}{ext}'
-        filepath = os.path.join(img_dir, filename)
+        logger.info(f"Starting PDF generation: {local_filename}")
         
-        with open(filepath, 'wb') as f:
-            f.write(response.content)
+        # 2. Initialize Generator
+        generator = Q4ReportGenerator(
+            title=title,
+            subtitle=subtitle,
+            author=author,
+            department=department,
+            confidential=True
+        )
         
-        abs_path = os.path.abspath(filepath)
-        file_uri = Path(abs_path).as_uri()
+        # 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
+        )
         
-        logger.info(f"Downloaded image: {url[:50]}... -> {filename}")
-        return file_uri
+        if not success:
+            raise Exception("PDF generation failed - generator returned False")
         
-    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 not os.path.exists(local_file_path):
+            raise Exception(f"PDF file not found after generation: {local_file_path}")
         
-        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 = ""
+        # 4. Upload to Supabase (Run in thread pool)
+        cloud_filename = f"{os.path.splitext(file_name)[0]}_{unique_id}.pdf"
         
-        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>"
+        logger.info(f"Uploading {local_filename} to Supabase as {cloud_filename}")
         
-        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>
-                    """
+        public_url = await run_in_threadpool(
+            _upload_to_supabase_sync,
+            file_path=local_file_path,
+            file_name=cloud_filename,
+            chat_id=chat_id
+        )
         
-        if section.get("page_break", False):
-            html += '<div class="page-break"></div>'
+        if not public_url:
+            raise Exception("Upload failed - no URL returned")
         
-        return html
-    
-    def generate(self, 
-                 sections: List[Dict], 
-                 filename: str = "Q4_Report.pdf",
-                 output_dir: str = "./output",
-                 cover_page: bool = True) -> bool:
+        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:
-            os.makedirs(output_dir, exist_ok=True)
-            output_path = os.path.join(output_dir, filename)
+            # Delete local PDF
+            if local_file_path:
+                _cleanup_files([local_file_path])
             
-            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
+            # 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