go

Dockerfile

@@ -3,20 +3,31 @@ FROM python:3.11-slim
 
 # Install system dependencies required for Math/Data libraries
 # libgomp1 is CRITICAL for scikit-learn & numpy parallelization to prevent segfaults
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
+RUN apt-get update && apt-get install -y --no-install-recommends \
     curl \
     gcc \
     g++ \
     libgomp1 \
+    libpango-1.0-0 \
+    libpangoft2-1.0-0 \
+    libjpeg62-turbo-dev \
+    libopenjp2-7-dev \
+    libffi-dev \
+    fonts-dejavu \
+    fonts-liberation \
     && rm -rf /var/lib/apt/lists/*
 
 # Set the working directory inside the container
-WORKDIR /app
+RUN mkdir -p /app/output \
+    /app/chat_pdfs \
+    /app/generated_charts \
+    /app/cache
 
 # Create required directories with permissions
-RUN mkdir -p /app/generated_outputs /app/generated_charts /app/cache && \
-    chmod -R 777 /app/generated_outputs /app/generated_charts /app/cache
+RUN chmod -R 777 /app/output \
+    /app/chat_pdfs \
+    /app/generated_charts \
+    /app/cache
 
 # Create log files
 RUN touch /app/pandasai.log /app/api_key_rotation.log && \
@@ -24,6 +35,7 @@ RUN touch /app/pandasai.log /app/api_key_rotation.log && \
 
 # Set environment variables
 ENV MPLCONFIGDIR=/app/cache
+ENV PYTHONUNBUFFERED=1
 
 # Copy requirements and install
 COPY requirements.txt .

controller.py

@@ -37,13 +37,15 @@ import uvicorn
 from csv_analysis_service import execute_analysis_logic
 from csv_chart_service import execute_python_code
 from csv_metadata_service import CsvDataRequest, CsvInfoRequest, CsvInfoResponse, PythonExecutionRequest, PythonExecutionResponse, execute_python_logic, get_csv_basic_info, get_robust_csv_rows
+from download_messages_log_helper import ChatLogRequest, ChatLogResponse, generate_chat_pdf
 from extract_csv_metadata_service import extract_csv_metadata_logic
 from mongo_service import convert_oid, execute_mongo_operation, extract_database_name, sanitize_json_input
 from pydantic_csv_analysis_model import AnalysisRequest, AnalysisResponse
 from pydantic_csv_charts_model import ChartExecutionPayload, ChartExecutionResponse
+from pydantic_migration_model import MigrationRequest, MigrationResponse
 from pydantic_mongo_executor_model import ExecutorPayload, ExecutorResponse
 from report_service import FileBoxProps, ReportRequest, execute_report_generation
-from supabase_service import upload_bytes_to_supabase
+from supabase_service import upload_bytes_to_supabase, upload_file_to_supabase
 from table_info_model import CsvFieldsRequest, CsvFieldsResponse
 
 # --- Configuration & Setup ---
@@ -367,6 +369,52 @@ async def _execute_async_postgres(db_url: str, sql_query: str, max_rows: int = 2
             }
     except Exception as e:
         return {"success": False, "error": str(e), "executionTime": 0.0}
+    
+# ==============================================================================
+# MIGRATION EXECUTORS
+# ==============================================================================
+async def _migrate_postgres(db_url: str, query: str) -> int:
+    """Executes a SQL script (Create + Insert) in Postgres"""
+    pool = await async_pool_manager.get_pg_pool(db_url)
+    async with pool.acquire() as conn:
+        async with conn.transaction():
+            # asyncpg can execute scripts with multiple statements using .execute()
+            # It returns string like "INSERT 0 100", "CREATE TABLE"
+            await conn.execute(query)
+            # We estimate rows by counting newlines in values or relying on frontend counts
+            # For accurate counts, we'd need to parse the return tag, but 'execute' 
+            # might run multiple statements.
+            return 0 # Row counting is handled by frontend or specific return parsing
+
+async def _migrate_mysql(db_url: str, query: str) -> int:
+    """Executes a SQL script in MySQL"""
+    pool = await async_pool_manager.get_mysql_pool(db_url)
+    async with pool.acquire() as conn:
+        async with conn.cursor() as cursor:
+            # asyncmy usually expects single statements unless client flags allow multi
+            # We will split by ';' for safety or execute raw if configured
+            statements = [s.strip() for s in query.split(';') if s.strip()]
+            for stmt in statements:
+                await cursor.execute(stmt)
+            return 0 
+
+def _migrate_mongo(db_url: str, collection_name: str, data: List[Dict]) -> int:
+    """Bulk Inserts documents into MongoDB"""
+    # Use existing extract logic
+    db_name = extract_database_name(db_url)
+    if not db_name:
+        raise ValueError("Could not determine database name from URI")
+    
+    from mongo_service import mongo_manager
+    client = mongo_manager.get_client(db_url)
+    db = client[db_name]
+    collection = db[collection_name]
+    
+    if not data:
+        return 0
+        
+    result = collection.insert_many(data)
+    return len(result.inserted_ids)
 
 # ==============================================================================
 # ROUTES
@@ -587,6 +635,144 @@ async def execute_python_endpoint(payload: PythonExecutionRequest, token: str =
         return PythonExecutionResponse(success=execution_result['error'] is None, output=execution_result['output'], result=jsonable_encoder(execution_result['result']), isStructured=execution_result['isStructured'], error=execution_result['error'], request_id=request_id)
     except Exception as e:
         raise HTTPException(status_code=500, detail={"success": False, "error": str(e), "request_id": request_id})
+    
+# --- Migration Route ---
+@app.post("/api/migrate", response_model=MigrationResponse)
+async def execute_migration_endpoint(payload: MigrationRequest, token: str = Depends(validate_token)):
+    request_id = str(uuid.uuid4())[:8]
+    start_time = time.time()
+    
+    try:
+        rows_processed = 0
+        
+        # 1. PostgreSQL Migration
+        if payload.db_type == 'postgresql':
+            if not payload.migration_query:
+                raise ValueError("Migration query is required for SQL databases")
+            
+            clean_url = normalize_postgres_uri(payload.db_url)
+            await _migrate_postgres(db_url=clean_url, query=payload.migration_query)
+            # Row count is difficult to get exactly from a multi-statement script 
+            # without complex parsing, usually the frontend knows how much data it sent.
+            rows_processed = payload.migration_query.upper().count("VALUES") # Rough estimate or 0
+            
+        # 2. MySQL Migration
+        elif payload.db_type == 'mysql':
+             if not payload.migration_query:
+                raise ValueError("Migration query is required for SQL databases")
+                
+             clean_url = normalize_mysql_uri(payload.db_url)
+             # Note: run_in_threadpool might be needed if async driver issues arise, 
+             # but here we defined async wrappers, so we await directly or use logic
+             # Since _migrate_mysql is async, we await it.
+             await _migrate_mysql(db_url=clean_url, query=payload.migration_query)
+             rows_processed = payload.migration_query.upper().count("VALUES")
+
+        # 3. MongoDB Migration
+        elif payload.db_type == 'mongodb':
+            if not payload.migration_data:
+                 raise ValueError("Migration data (JSON) is required for MongoDB")
+            if not payload.collection_name:
+                 raise ValueError("Collection name is required for MongoDB")
+                 
+            # Mongo operations are blocking in pymongo, so run in threadpool
+            rows_processed = await run_in_threadpool(
+                _migrate_mongo, 
+                db_url=payload.db_url, 
+                collection_name=payload.collection_name, 
+                data=payload.migration_data
+            )
+            
+        else:
+            raise ValueError(f"Unsupported database type: {payload.db_type}")
+
+        duration = f"{time.time() - start_time:.2f}s"
+        
+        logger.info(f"Migration Complete: {rows_processed} batches processed in {duration}")
+        
+        return MigrationResponse(
+            success=True,
+            rowsProcessed=rows_processed,
+            duration=duration,
+            errors=[],
+            request_id=request_id
+        )
+
+    except Exception as e:
+        logger.error(f"Migration Failed: {e}")
+        duration = f"{time.time() - start_time:.2f}s"
+        return MigrationResponse(
+            success=False,
+            rowsProcessed=0,
+            duration=duration,
+            errors=[str(e)],
+            request_id=request_id
+        )
+        
+# --- CSV Metadata ---
+@app.post("/api/get_csv_fields", response_model=CsvFieldsResponse)
+async def get_csv_fields_endpoint(payload: CsvFieldsRequest, token: str = Depends(validate_token)):
+    request_id = str(uuid.uuid4())[:8]
+    try:
+        fields = await run_in_threadpool(extract_csv_metadata_logic, csv_url=payload.csv_url)
+        return CsvFieldsResponse(success=True, fields=fields, request_id=request_id)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail={"success": False, "error": str(e), "request_id": request_id})
+        
+# --- Chat Messages Log ---
+@app.post("/api/get_chat_log", response_model=ChatLogResponse)
+async def get_chat_log_endpoint(payload: ChatLogRequest, token: str = Depends(validate_token)):
+    request_id = str(uuid.uuid4())[:8]
+    generated_pdf_path = None
+    
+    try:
+        # 1. Generate the PDF locally
+        # run_in_threadpool is crucial here because PDF generation is CPU/IO blocking
+        generated_pdf_path = await run_in_threadpool(
+            generate_chat_pdf,
+            messages=payload.messages,
+            title=payload.title,
+            chat_id=payload.chatId,
+            output_dir="chat_pdfs", # Matches the default in your helper
+            include_stats=True
+        )
+
+        if not generated_pdf_path or not os.path.exists(generated_pdf_path):
+            raise Exception("PDF generation failed or file not found.")
+
+        # 2. Upload to Supabase
+        # Extract filename from path (e.g., "chat_log_123.pdf")
+        filename = os.path.basename(generated_pdf_path)
+        
+        public_url = await run_in_threadpool(
+            upload_file_to_supabase,
+            file_path=generated_pdf_path,
+            file_name=filename,
+            chat_id=payload.chatId
+        )
+
+        return ChatLogResponse(
+            success=True,
+            pdf_url=public_url,
+            request_id=request_id,
+            message="PDF generated and uploaded successfully."
+        )
+
+    except Exception as e:
+        logger.error(f"Chat Log Error [{request_id}]: {str(e)}")
+        raise HTTPException(
+            status_code=500, 
+            detail={"success": False, "error": str(e), "request_id": request_id}
+        )
+        
+    finally:
+        # 3. Cleanup: Delete the local file to save space
+        if generated_pdf_path and os.path.exists(generated_pdf_path):
+            try:
+                os.remove(generated_pdf_path)
+                logger.info(f"Cleaned up local PDF: {generated_pdf_path}")
+            except Exception as cleanup_error:
+                logger.warning(f"Failed to delete local PDF {generated_pdf_path}: {cleanup_error}")
 
 # --- Batch Handlers ---
 async def batch_parallel_handler(func, requests: List[Any], token: str):
@@ -633,15 +819,6 @@ async def root():
 async def ping():
     return {"message": "I am alive!"}
 
-@app.post("/api/get_csv_fields", response_model=CsvFieldsResponse)
-async def get_csv_fields_endpoint(payload: CsvFieldsRequest, token: str = Depends(validate_token)):
-    request_id = str(uuid.uuid4())[:8]
-    try:
-        fields = await run_in_threadpool(extract_csv_metadata_logic, csv_url=payload.csv_url)
-        return CsvFieldsResponse(success=True, fields=fields, request_id=request_id)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail={"success": False, "error": str(e), "request_id": request_id})
-
 if __name__ == "__main__":
     host = os.getenv("HOST", "0.0.0.0")
     port = int(os.getenv("PORT", 7860))

download_messages_log_helper.py

@@ -0,0 +1,87 @@
+# ---------------------------------------------------------
+# HELPER METHOD FOR QUICK PDF GENERATION
+# ---------------------------------------------------------
+from typing import Dict, List, Optional
+import logging
+
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+
+class ChatLogRequest(BaseModel):
+    chatId: str = Field(..., description="Unique identifier for the chat session")
+    messages: List[Dict[str, Any]] = Field(..., description="List of message objects containing content, role, etc.")
+    title: Optional[str] = "Chat Conversation Log"
+
+class ChatLogResponse(BaseModel):
+    success: bool
+    pdf_url: str
+    request_id: str
+    message: Optional[str] = None
+
+from download_messages_service import ChatLogGenerator
+
+logger = logging.getLogger(__name__)
+
+
+def generate_chat_pdf(messages: List[Dict],
+                     title: str = "Chat Conversation Log",
+                     chat_id: str = None,
+                     output_dir: str = "chat_pdfs",
+                     participants: List[str] = None,
+                     date_range: str = None,
+                     cover_page: bool = False,
+                     include_stats: bool = True) -> Optional[str]:
+    """
+    Quick helper method to generate a chat PDF and return the file path.
+    
+    Args:
+        messages: List of message dictionaries
+        title: Title of the chat log
+        chat_id: Unique chat identifier
+        output_dir: Directory to save PDF
+        participants: List of participant names
+        date_range: Date range of conversation
+        cover_page: Whether to include cover page
+        include_stats: Whether to include statistics
+    
+    Returns:
+        Full path to generated PDF file, or None if failed
+    
+    Example:
+        messages = [{"role": "user", "content": "Hello", "createdAt": "2026-01-10T09:00:00Z"}]
+        pdf_path = generate_chat_pdf(messages, title="My Chat", chat_id="abc123")
+        logger.info(f"PDF saved at: {pdf_path}")
+    """
+    try:
+        logger.info(f"Generating chat PDF: {title}")
+        
+        generator = ChatLogGenerator(
+            title=title,
+            chat_id=chat_id,
+            participants=participants,
+            date_range=date_range,
+            output_dir=output_dir
+        )
+        
+        # Generate unique filename
+        filename = generator._generate_unique_filename()
+        
+        # Generate PDF
+        success = generator.generate(
+            messages=messages,
+            filename=filename,
+            cover_page=cover_page,
+            include_stats=include_stats
+        )
+        
+        if success:
+            logger.info(f"PDF successfully generated: {filename}")
+            return filename
+        else:
+            logger.error("PDF generation failed")
+            return None
+            
+    except Exception as e:
+        logger.exception(f"Error generating PDF: {e}")
+        return None
+

download_messages_service.py

@@ -0,0 +1,941 @@
+"""
+Professional Chat Message Log PDF Generator
+Generates beautifully formatted PDF reports from chat conversations
+Uses WeasyPrint for superior CSS support and rendering
+Supports file attachments (CSV and Image files)
+"""
+import markdown
+from weasyprint import HTML, CSS
+import requests
+import os
+import tempfile
+import re
+from datetime import datetime
+from typing import List, Dict, Optional
+import json
+import random
+import string
+import logging
+
+# ---------------------------------------------------------
+# LOGGING CONFIGURATION
+# ---------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------
+# CHAT LOG THEME - WEASYPRINT OPTIMIZED
+# ---------------------------------------------------------
+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.6;
+    font-size: 11pt;
+}
+
+.header {
+    position: running(header);
+    font-size: 9pt;
+    color: #666;
+    border-bottom: 1px solid #ddd;
+    padding-bottom: 4px;
+    margin-bottom: 20px;
+}
+
+.footer {
+    position: running(footer);
+    font-size: 9pt;
+    color: #666;
+    border-top: 1px solid #ddd;
+    padding-top: 4px;
+    text-align: center;
+}
+
+.cover-page {
+    text-align: center;
+    padding-top: 3in;
+    page-break-after: always;
+}
+
+.cover-title {
+    font-size: 32pt;
+    font-weight: bold;
+    color: #003366;
+    margin-bottom: 0.5in;
+    letter-spacing: 1px;
+}
+
+.cover-subtitle {
+    font-size: 18pt;
+    color: #0055a5;
+    margin-bottom: 1in;
+}
+
+.cover-meta {
+    font-size: 14pt;
+    color: #666;
+    margin-bottom: 0.2in;
+}
+
+.cover-date {
+    font-size: 11pt;
+    color: #999;
+}
+
+.message-container {
+    margin-bottom: 20px;
+    page-break-inside: avoid;
+}
+
+.message-user {
+    background-color: #ffffff;
+    border-left: 0.5px solid #0055a5;
+    padding: 16px 20px;
+    margin-bottom: 16px;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+}
+
+.message-assistant {
+    background-color: #ffffff;
+    border-left: 0.5px solid #003366;
+    padding: 16px 20px;
+    margin-bottom: 16px;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+}
+
+.message-header {
+    font-weight: bold;
+    font-size: 10pt;
+    margin-bottom: 8px;
+    display: flex;
+    justify-content: space-between;
+}
+
+.role-user {
+    color: #003366;
+    font-size: 11pt;
+}
+
+.role-assistant {
+    color: #003366;
+    font-size: 11pt;
+}
+
+.timestamp {
+    font-size: 9pt;
+    color: #999;
+    font-weight: normal;
+}
+
+.message-content {
+    color: #333;
+    font-size: 10pt;
+    line-height: 1.5;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+}
+
+a {
+    color: #0055a5;
+    text-decoration: none;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+.message-content a {
+    font-weight: 500;
+}
+
+.message-divider {
+    border-top: 1px solid #ddd;
+    margin: 16px 0;
+}
+
+h1, h2, h3, h4 {
+    color: #003366;
+    margin-top: 12px;
+    margin-bottom: 8px;
+}
+
+h1 { font-size: 16pt; }
+h2 { font-size: 14pt; color: #0055a5; }
+h3 { font-size: 12pt; }
+h4 { font-size: 11pt; }
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+    margin: 12px 0;
+    font-size: 9pt;
+    table-layout: fixed;
+}
+
+/* For tables with many columns, reduce font size */
+table.many-columns {
+    font-size: 7pt;
+}
+
+table.many-columns th,
+table.many-columns td {
+    padding: 4px 6px;
+}
+
+th {
+    background-color: #003366;
+    color: white;
+    padding: 8px;
+    text-align: left;
+    font-weight: bold;
+    border: 1px solid #002244;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    hyphens: auto;
+}
+
+td {
+    padding: 6px 8px;
+    border: 1px solid #ddd;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    max-width: 0;
+    overflow: hidden;
+    hyphens: auto;
+    font-size: inherit;
+}
+
+tr:nth-child(even) {
+    background-color: #f8f9fa;
+}
+
+code {
+    background-color: #f0f7ff;
+    padding: 2px 6px;
+    border-radius: 4px;
+    font-family: 'Courier New', monospace;
+    font-size: 9pt;
+    color: #1a1a1a;
+}
+
+pre {
+    background-color: #f0f7ff;
+    border: 1px solid #c7ddff;
+    border-left: none;
+    padding: 12px;
+    font-size: 8pt;
+    line-height: 1.4;
+    margin: 10px 0;
+    border-radius: 6px;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+}
+
+pre code {
+    background-color: transparent;
+    padding: 0;
+    color: #1a1a1a;
+}
+
+blockquote {
+    border-left: 3px solid #0055a5;
+    margin-left: 0;
+    padding-left: 12px;
+    color: #555;
+    font-style: italic;
+    background-color: #f8f9fa;
+    padding: 8px 8px 8px 12px;
+    margin: 10px 0;
+}
+
+ul, ol {
+    margin: 8px 0;
+    padding-left: 20px;
+    list-style-type: none;
+}
+
+ul li:before {
+    content: "• ";
+    color: #0055a5;
+    font-weight: bold;
+    display: inline-block;
+    width: 1em;
+    margin-left: -1em;
+}
+
+li {
+    margin: 4px 0;
+}
+
+.figure-container {
+    text-align: center;
+    margin: 16px 0;
+    page-break-inside: avoid;
+}
+
+.figure-container img {
+    max-width: 100%;
+    max-height: 400px;
+    height: auto;
+    border: 1px solid #ddd;
+    padding: 4px;
+    background: white;
+}
+
+.figure-caption {
+    font-size: 9pt;
+    color: #666;
+    margin-top: 6px;
+    font-style: italic;
+}
+
+.file-item {
+    margin-bottom: 12px;
+    padding: 12px;
+    background-color: #f8f9fa;
+    border-left: 3px solid #0055a5;
+    page-break-inside: avoid;
+}
+
+.file-label {
+    color: #003366;
+    font-weight: bold;
+    font-size: 9pt;
+}
+
+.file-value {
+    color: #333;
+    font-size: 9pt;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+}
+
+.file-url {
+    color: #0055a5;
+    font-size: 7pt;
+    font-family: 'Courier New', monospace;
+    display: block;
+    padding: 6px 8px;
+    background-color: #f0f7ff;
+    border-radius: 3px;
+    margin-top: 4px;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    line-height: 1.5;
+}
+
+.file-url a {
+    color: #0055a5;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    font-size: 7pt;
+    font-family: 'Courier New', monospace;
+}
+
+.stats-summary {
+    margin: 30px 0 20px 0;
+}
+
+.stats-summary p {
+    margin: 0;
+    padding: 0;
+    font-size: 10pt;
+    color: #666;
+}
+
+.stats-summary strong {
+    color: #003366;
+}
+
+.section-divider {
+    border: none;
+    border-top: 2px solid #0055a5;
+    margin: 20px 0 30px 0;
+}
+"""
+
+# ---------------------------------------------------------
+# CHAT LOG GENERATOR CLASS
+# ---------------------------------------------------------
+class ChatLogGenerator:
+    """
+    Generates professional PDF reports from chat message logs.
+    Supports multiple JSON formats (createdAt, timestamp, chatId, chat_id, etc.)
+    """
+    
+    def __init__(self, 
+                 title: str = "Chat Conversation Log",
+                 chat_id: str = None,
+                 participants: List[str] = None,
+                 date_range: str = None,
+                 confidential: bool = False,
+                 output_dir: str = "chat_pdfs"):
+        """
+        Initialize the chat log generator.
+        
+        Args:
+            title: Title of the chat log report
+            chat_id: Unique identifier for the chat session
+            participants: List of participant names
+            date_range: Date range of the conversation
+            confidential: Whether to mark as confidential
+            output_dir: Directory to save PDF files
+        """
+        self.title = title
+        self.chat_id = chat_id
+        self.participants = participants or ["User", "Assistant"]
+        self.date_range = date_range
+        self.confidential = confidential
+        self.output_dir = output_dir
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(self.output_dir, exist_ok=True)
+        logger.info(f"ChatLogGenerator initialized - output_dir: {self.output_dir}")
+    
+    def _get_timestamp_from_message(self, message: Dict) -> str:
+        """
+        Extract timestamp from message, checking multiple possible field names.
+        Supports: timestamp, createdAt, created_at
+        """
+        # Try different field names
+        for field in ['timestamp', 'createdAt', 'created_at']:
+            if field in message and message[field]:
+                return message[field]
+        
+        # Return empty string if no timestamp found
+        return ''
+    
+    def _generate_unique_filename(self, base_name: str = "chat_log") -> str:
+        """
+        Generate a unique filename with random number.
+        
+        Args:
+            base_name: Base name for the file
+            
+        Returns:
+            Full path to the PDF file
+        """
+        # Generate random 8-digit number
+        random_num = ''.join(random.choices(string.digits, k=8))
+        
+        # Get current timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # Create filename
+        filename = f"{base_name}_{timestamp}_{random_num}.pdf"
+        
+        # Return full path
+        filepath = os.path.join(self.output_dir, filename)
+        logger.debug(f"Generated unique filename: {filepath}")
+        return filepath
+    
+    def _format_timestamp(self, timestamp: str) -> str:
+        """
+        Format ISO timestamp to readable format.
+        Handles both with and without timezone info.
+        """
+        if not timestamp or timestamp.strip() == '':
+            return "No timestamp"
+        
+        try:
+            # Try parsing with timezone first
+            if '+' in timestamp or timestamp.endswith('Z'):
+                dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+            else:
+                # Try parsing without timezone
+                dt = datetime.fromisoformat(timestamp)
+            
+            return dt.strftime("%B %d, %Y at %I:%M:%S %p")
+        except Exception as e:
+            logger.warning(f"Failed to parse timestamp: {timestamp} - {e}")
+            return timestamp if timestamp else "No timestamp"
+    
+    def _convert_markdown_with_inline_images(self, content: str) -> str:
+        """
+        Convert markdown to HTML while preserving inline image positions.
+        Images will appear exactly where they're referenced.
+        Standalone image URLs are hidden from display.
+        Auto-converts URLs to "Click to View" links.
+        """
+        # Pattern to match markdown images: ![alt](url)
+        image_pattern = r'!\[([^\]]*)\]\(([^\)]+)\)'
+        
+        # Find all image URLs that will be converted to <img> tags
+        image_urls = set()
+        for match in re.finditer(image_pattern, content):
+            image_urls.add(match.group(2))
+        
+        # Split content by images while keeping the images
+        parts = re.split(f'({image_pattern})', content)
+        
+        html_output = ""
+        i = 0
+        
+        while i < len(parts):
+            part = parts[i]
+            
+            # Check if this part is an image (starts with ![)
+            if part.startswith('!['):
+                # Extract alt text and URL from the matched groups
+                match = re.match(image_pattern, part)
+                if match:
+                    alt_text = match.group(1) or "Figure"
+                    url = match.group(2)
+                    
+                    # Add the image HTML inline
+                    html_output += f"""
+                    <div class="figure-container">
+                        <img src="{url}" alt="{alt_text}">
+                        <div class="figure-caption">{alt_text}</div>
+                    </div>
+                    """
+                i += 1
+            else:
+                # Regular text content - process URLs and hide standalone image URLs
+                if part.strip():
+                    # Remove standalone image URLs that appear on their own lines
+                    processed_part = self._hide_standalone_image_urls(part, image_urls)
+                    
+                    # Convert URLs to "Click to View" links BEFORE markdown conversion
+                    processed_part = self._convert_urls_to_links(processed_part)
+                    
+                    # Convert markdown to HTML
+                    html_output += markdown.markdown(
+                        processed_part,
+                        extensions=['extra', 'sane_lists', 'tables', 'fenced_code', 'nl2br']
+                    )
+                i += 1
+        
+        # Post-process tables to add responsive class for wide tables
+        html_output = self._make_tables_responsive(html_output)
+        
+        return html_output
+    
+    def _make_tables_responsive(self, html: str) -> str:
+        """
+        Add 'many-columns' class to tables with more than 10 columns.
+        This reduces font size and padding for better fit.
+        """
+        # Pattern to find tables
+        table_pattern = r'<table>(.*?)</table>'
+        
+        def process_table(match):
+            table_content = match.group(1)
+            
+            # Count columns by finding <th> tags in the first row
+            th_count = table_content.count('<th>')
+            
+            # If more than 10 columns, add the many-columns class
+            if th_count > 10:
+                return f'<table class="many-columns">{table_content}</table>'
+            else:
+                return match.group(0)
+        
+        return re.sub(table_pattern, process_table, html, flags=re.DOTALL)
+    
+    def _convert_urls_to_links(self, text: str) -> str:
+        """
+        Convert standalone URLs (http:// or https://) to "Click to View" links.
+        """
+        lines = text.split('\n')
+        processed_lines = []
+        
+        for line in lines:
+            stripped = line.strip()
+            
+            # Check if line starts with http:// or https://
+            if stripped.startswith('http://') or stripped.startswith('https://'):
+                # Check if it's already a markdown link [text](url)
+                if not line.strip().startswith('['):
+                    # Convert to "Click to View" link
+                    processed_lines.append(f'<a href="{stripped}" style="color: #0055a5; text-decoration: underline; font-weight: bold;">Click to View</a>')
+                else:
+                    processed_lines.append(line)
+            else:
+                # Check for URLs within the line
+                # Pattern to find URLs not already in markdown links
+                url_pattern = r'(?<!\])\(?(https?://[^\s\)]+)\)?(?!\])'
+                
+                def replace_url(match):
+                    url = match.group(1)
+                    return f'<a href="{url}" style="color: #0055a5; text-decoration: underline; font-weight: bold;">Click to View</a>'
+                
+                processed_line = re.sub(url_pattern, replace_url, line)
+                processed_lines.append(processed_line)
+        
+        return '\n'.join(processed_lines)
+    
+    def _hide_standalone_image_urls(self, text: str, image_urls: set) -> str:
+        """
+        Hide standalone image URLs that are already displayed as images.
+        Keep other HTTP links intact.
+        """
+        lines = text.split('\n')
+        processed_lines = []
+        
+        for line in lines:
+            stripped = line.strip()
+            
+            # Check if this line is ONLY an image URL (already shown as image)
+            if stripped in image_urls:
+                # Skip this line entirely (don't add it)
+                continue
+            
+            # Check if line is just a URL with optional markdown link wrapper
+            # Pattern: https://... or [text](https://...)
+            url_only_pattern = r'^<?https?://[^\s>]+>?$'
+            if re.match(url_only_pattern, stripped):
+                # Keep the line as is
+                processed_lines.append(line)
+            else:
+                processed_lines.append(line)
+        
+        return '\n'.join(processed_lines)
+    
+    def _build_files_section(self, files_data: Dict) -> str:
+        """
+        Build HTML section for CSV and image files.
+        Shows "Click to View" as clickable link for URLs.
+        """
+        if not files_data:
+            return ""
+        
+        html = '<div style="margin: 30px 0; page-break-inside: avoid;">'
+        html += '<h2 style="color: #003366; border-bottom: 2px solid #0055a5; padding-bottom: 8px; margin-bottom: 20px;">Attached Files</h2>'
+        
+        # CSV Files section
+        csv_files = files_data.get('csv_files', [])
+        if csv_files and len(csv_files) > 0:
+            html += '<h3 style="color: #0055a5; margin-top: 20px; margin-bottom: 12px;">CSV Files:</h3>'
+            
+            for csv_file in csv_files:
+                file_name = csv_file.get('fileName', 'Unknown')
+                file_path = csv_file.get('filePath', 'Unknown')
+                
+                # Check if it's a URL
+                is_url = file_path.startswith('http://') or file_path.startswith('https://')
+                
+                html += f'''
+                <div class="file-item">
+                    <div><span class="file-label">File Name:</span> <span class="file-value">{file_name}</span></div>
+                    <div style="margin-top: 6px;"><span class="file-label">File URL:</span></div>
+                '''
+                
+                if is_url:
+                    # Show clickable "Click to View" link
+                    html += f'''
+                    <div style="margin-top: 2px;">
+                        <a href="{file_path}" style="color: #0055a5; text-decoration: underline; font-weight: bold; font-size: 9pt;">Click to View</a>
+                    </div>
+                    '''
+                else:
+                    # Just show the text
+                    html += f'''
+                    <div class="file-value" style="margin-top: 2px;">{file_path}</div>
+                    '''
+                
+                html += f'''
+                    <div style="margin-top: 6px;"><span class="file-label">File Type:</span> <span class="file-value">CSV</span></div>
+                </div>
+                '''
+        
+        # Image Files section
+        image_files = files_data.get('image_files', [])
+        if image_files and len(image_files) > 0:
+            html += '<h3 style="color: #0055a5; margin-top: 20px; margin-bottom: 12px;">Image Files:</h3>'
+            
+            for img_file in image_files:
+                file_name = img_file.get('fileName', 'Unknown')
+                file_path = img_file.get('filePath', 'Unknown')
+                
+                # Check if it's a URL
+                is_url = file_path.startswith('http://') or file_path.startswith('https://')
+                
+                html += f'''
+                <div class="file-item">
+                    <div><span class="file-label">File Name:</span> <span class="file-value">{file_name}</span></div>
+                    <div style="margin-top: 6px;"><span class="file-label">File URL:</span></div>
+                '''
+                
+                if is_url:
+                    # Show clickable "Click to View" link
+                    html += f'''
+                    <div style="margin-top: 2px;">
+                        <a href="{file_path}" style="color: #0055a5; text-decoration: underline; font-weight: bold; font-size: 9pt;">Click to View</a>
+                    </div>
+                    '''
+                else:
+                    # Just show the text
+                    html += f'''
+                    <div class="file-value" style="margin-top: 2px;">{file_path}</div>
+                    '''
+                
+                html += f'''
+                    <div style="margin-top: 6px;"><span class="file-label">File Type:</span> <span class="file-value">Image</span></div>
+                </div>
+                '''
+        
+        html += '</div>'
+        html += '<hr class="section-divider">'
+        
+        return html
+    
+    def _build_message_html(self, message: Dict) -> str:
+        """
+        Build HTML for a single message with inline images.
+        """
+        role = message.get('role', message.get('Role', 'user'))
+        content = message.get('content', message.get('Content', ''))
+        
+        # Get timestamp from any available field
+        timestamp = self._get_timestamp_from_message(message)
+        
+        # Get image if present
+        direct_image = message.get('image', message.get('Image', ''))
+        
+        # Process markdown with images inline
+        html_content = self._convert_markdown_with_inline_images(content)
+        
+        # Determine styling
+        container_class = "message-user" if role == "user" else "message-assistant"
+        role_class = "role-user" if role == "user" else "role-assistant"
+        role_display = "User" if role == "user" else "Assistant"
+        
+        formatted_time = self._format_timestamp(timestamp)
+        
+        # Build message HTML
+        html = f"""
+        <div class="message-container">
+            <div class="{container_class}">
+                <div class="message-header">
+                    <span class="{role_class}">{role_display}</span>
+                    <span class="timestamp">{formatted_time}</span>
+                </div>
+                <div class="message-content">
+                    {html_content}
+                </div>
+            </div>
+        """
+        
+        # Add direct image attachment if present (at the end)
+        if direct_image:
+            html += f"""
+            <div class="figure-container">
+                <img src="{direct_image}" alt="Attached image">
+                <div class="figure-caption">Attached Image</div>
+            </div>
+            """
+        
+        html += "</div>"
+        
+        return html
+    
+    def _build_header(self) -> str:
+        """Build the report header."""
+        header_text = self.title
+        if self.chat_id:
+            header_text += f" | {self.chat_id}"
+        
+        return f"""
+        <div class="header">
+            {header_text}
+        </div>
+        """
+    
+    def _build_footer(self) -> str:
+        """Build the report footer with page number."""
+        return """
+        <div class="footer">
+            Page <span class="page-number"></span>
+        </div>
+        """
+    
+    def _build_cover_page(self, message_count: int) -> str:
+        """Build a professional cover page."""
+        current_date = datetime.now().strftime("%B %d, %Y")
+        
+        cover_html = f"""
+        <div class="cover-page">
+            <div class="cover-title">{self.title}</div>
+        """
+        
+        if self.date_range:
+            cover_html += f'<div class="cover-subtitle">{self.date_range}</div>'
+        
+        if self.chat_id:
+            cover_html += f'<div class="cover-meta">Chat ID: {self.chat_id}</div>'
+        
+        cover_html += f'<div class="cover-meta">Total Messages: {message_count}</div>'
+        
+        if self.participants and len(self.participants) > 0:
+            participants_str = ", ".join(self.participants)
+            cover_html += f'<div class="cover-meta">Participants: {participants_str}</div>'
+        
+        cover_html += f'<div class="cover-date">Generated on {current_date}</div>'
+        cover_html += '</div>'
+        
+        logger.debug("Built cover page")
+        return cover_html
+    
+    def _build_stats_summary(self, messages: List[Dict]) -> str:
+        """Build a compact statistics summary with horizontal line."""
+        total = len(messages)
+        user_count = sum(1 for m in messages if m.get('role', m.get('Role')) == 'user')
+        assistant_count = sum(1 for m in messages if m.get('role', m.get('Role')) == 'assistant')
+        
+        # Get date range from messages - check all possible timestamp fields
+        timestamps = []
+        for m in messages:
+            ts = self._get_timestamp_from_message(m)
+            if ts:
+                timestamps.append(ts)
+        
+        if timestamps:
+            try:
+                dates = []
+                for ts in timestamps:
+                    if '+' in ts or ts.endswith('Z'):
+                        dates.append(datetime.fromisoformat(ts.replace('Z', '+00:00')))
+                    else:
+                        dates.append(datetime.fromisoformat(ts))
+                
+                first_date = min(dates).strftime("%B %d, %Y")
+                last_date = max(dates).strftime("%B %d, %Y")
+                date_info = f"{first_date} to {last_date}"
+            except Exception as e:
+                logger.warning(f"Failed to parse date range: {e}")
+                date_info = "Date unavailable"
+        else:
+            date_info = "Date unavailable"
+        
+        logger.info(f"Stats - Total: {total}, User: {user_count}, Assistant: {assistant_count}")
+        
+        return f"""
+        <div class="stats-summary">
+            <p>
+                <strong>Total Messages:</strong> {total} &nbsp;&nbsp;|&nbsp;&nbsp;
+                <strong>User:</strong> {user_count} &nbsp;&nbsp;|&nbsp;&nbsp;
+                <strong>Assistant:</strong> {assistant_count} &nbsp;&nbsp;|&nbsp;&nbsp;
+                <strong>Period:</strong> {date_info}
+            </p>
+        </div>
+        <hr class="section-divider">
+        """
+    
+    def generate_from_json(self, 
+                          json_data: str, 
+                          filename: str = None,
+                          cover_page: bool = True,
+                          include_stats: bool = True) -> bool:
+        """
+        Generate PDF from JSON string.
+        """
+        try:
+            messages = json.loads(json_data)
+            logger.info("Successfully parsed JSON data")
+            return self.generate(messages, filename, cover_page, include_stats)
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON: {e}")
+            return False
+    
+    def generate(self, 
+                messages: List[Dict], 
+                filename: str = None,
+                cover_page: bool = True,
+                include_stats: bool = True,
+                files: Dict = None) -> bool:
+        """
+        Generate the PDF chat log using WeasyPrint.
+        """
+        try:
+            if not messages or len(messages) == 0:
+                logger.error("No messages to process")
+                return False
+            
+            logger.info(f"Starting PDF generation for {len(messages)} messages")
+            
+            # Generate unique filename if not provided
+            if filename is None:
+                filename = self._generate_unique_filename()
+            else:
+                # If filename provided without path, put it in output_dir
+                if not os.path.dirname(filename):
+                    filename = os.path.join(self.output_dir, filename)
+            
+            # Build report body
+            report_body = ""
+            
+            # Add cover page
+            if cover_page:
+                report_body += self._build_cover_page(len(messages))
+            
+            # Add statistics summary with horizontal line
+            if include_stats:
+                report_body += self._build_stats_summary(messages)
+            
+            # Add files section if provided
+            if files:
+                report_body += self._build_files_section(files)
+            
+            # Add all messages
+            for i, message in enumerate(messages):
+                report_body += self._build_message_html(message)
+                
+                # Add divider between messages (except last)
+                if i < len(messages) - 1:
+                    report_body += '<div class="message-divider"></div>'
+            
+            # Assemble full HTML
+            full_html = f"""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <style>
+                    {CSS_STYLE}
+                    .page-number:before {{ content: counter(page); }}
+                </style>
+            </head>
+            <body>
+                {self._build_header()}
+                {self._build_footer()}
+                {report_body}
+            </body>
+            </html>
+            """
+            
+            # Generate PDF with WeasyPrint
+            logger.info(f"Writing PDF to: {filename}")
+            
+            # Create HTML object and render to PDF
+            html_obj = HTML(string=full_html)
+            html_obj.write_pdf(filename)
+            
+            logger.info(f"Success! Chat log generated: {filename}")
+            logger.info(f"{len(messages)} messages processed")
+            return True
+                    
+        except Exception as e:
+            logger.exception(f"Error generating PDF: {e}")
+            return False

pydantic_migration_model.py

@@ -0,0 +1,28 @@
+# pydantic_migration_model.py
+from pydantic import BaseModel, Field
+from typing import List, Optional, Union, Dict, Any
+
+class MigrationRequest(BaseModel):
+    db_url: str = Field(..., description="The connection string for the target database")
+    db_type: str = Field(..., description="postgres, mysql, or mongodb")
+    
+    # For SQL Databases, this is the raw SQL Script (CREATE + INSERT)
+    # For MongoDB, this is ignored (we use migration_data)
+    migration_query: Optional[str] = None 
+    
+    # For MongoDB, we pass the raw JSON documents to insert
+    # For SQL, this is ignored
+    migration_data: Optional[List[Dict[str, Any]]] = None
+    
+    # Metadata for MongoDB
+    collection_name: Optional[str] = None
+    
+    # Options
+    batch_size: int = 1000
+
+class MigrationResponse(BaseModel):
+    success: bool
+    rowsProcessed: int
+    errors: Optional[List[str]] = []
+    duration: str
+    request_id: str

requirements.txt

@@ -22,3 +22,7 @@ psutil==6.1.1
 asyncpg==0.30.0
 asyncmy==0.2.10
 cryptography==43.0.3
+weasyprint==67.0
+markdown==3.7
+requests==2.32.3
+jinja2==3.1.4