Upload 33 files

backend/main.py

@@ -1,6 +1,6 @@
 from fastapi import FastAPI, File, UploadFile, Form, HTTPException
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, FileResponse
 import uvicorn
 import os
 from typing import List, Optional
@@ -11,6 +11,9 @@ import uuid
 # Import AI functionality modules
 from modules.document_processor import process_document
 from modules.image_processor import process_image
+from modules.question_answering import process_question
+from modules.data_visualization import generate_visualization
+from modules.translator import translate_document
 
 # Create FastAPI app
 app = FastAPI(title="AI Document Analysis API")
@@ -19,12 +22,13 @@ app = FastAPI(title="AI Document Analysis API")
 UPLOAD_DIR = Path("uploads")
 UPLOAD_DIR.mkdir(exist_ok=True)
 
-# Mount static files - updated path to be relative to the current directory
+# Mount static files
 app.mount("/static", StaticFiles(directory="frontend"), name="static")
 
+# Serve index.html at root
 @app.get("/")
-def read_root():
-    return {"message": "AI Document Analysis API is running"}
+async def read_root():
+    return FileResponse("frontend/index.html")
 
 @app.post("/api/analyze-document")
 async def analyze_document(
@@ -104,6 +108,114 @@ async def analyze_image(
             os.remove(file_path)
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.post("/api/question-answering")
+async def question_answering(
+    file: UploadFile = File(...),
+    question: str = Form(...)
+):
+    # Validate file type
+    allowed_extensions = [".pdf", ".docx", ".pptx", ".xlsx", ".xls", ".jpg", ".jpeg", ".png"]
+    file_ext = os.path.splitext(file.filename)[1].lower()
+    
+    if file_ext not in allowed_extensions:
+        raise HTTPException(status_code=400, detail=f"File type not supported. Allowed types: {', '.join(allowed_extensions)}")
+    
+    # Create unique filename
+    unique_filename = f"{uuid.uuid4()}{file_ext}"
+    file_path = UPLOAD_DIR / unique_filename
+    
+    # Save uploaded file
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    try:
+        # Process question
+        result = process_question(str(file_path), question)
+        
+        # Return results
+        return {
+            "filename": file.filename,
+            "question": question,
+            "answer": result
+        }
+    except Exception as e:
+        # Clean up file on error
+        if file_path.exists():
+            os.remove(file_path)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/visualize-data")
+async def visualize_data(
+    file: UploadFile = File(...),
+    request: str = Form(...)
+):
+    # Validate file type
+    allowed_extensions = [".xlsx", ".xls"]
+    file_ext = os.path.splitext(file.filename)[1].lower()
+    
+    if file_ext not in allowed_extensions:
+        raise HTTPException(status_code=400, detail=f"File type not supported. Allowed types: {', '.join(allowed_extensions)}")
+    
+    # Create unique filename
+    unique_filename = f"{uuid.uuid4()}{file_ext}"
+    file_path = UPLOAD_DIR / unique_filename
+    
+    # Save uploaded file
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    try:
+        # Generate visualization
+        result = generate_visualization(str(file_path), request)
+        
+        # Return results
+        return {
+            "filename": file.filename,
+            "request": request,
+            "visualization": result
+        }
+    except Exception as e:
+        # Clean up file on error
+        if file_path.exists():
+            os.remove(file_path)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/translate-document")
+async def translate_document_endpoint(
+    file: UploadFile = File(...),
+    target_language: str = Form(...)
+):
+    # Validate file type
+    allowed_extensions = [".pdf", ".docx", ".pptx", ".xlsx", ".xls"]
+    file_ext = os.path.splitext(file.filename)[1].lower()
+    
+    if file_ext not in allowed_extensions:
+        raise HTTPException(status_code=400, detail=f"File type not supported. Allowed types: {', '.join(allowed_extensions)}")
+    
+    # Create unique filename
+    unique_filename = f"{uuid.uuid4()}{file_ext}"
+    file_path = UPLOAD_DIR / unique_filename
+    
+    # Save uploaded file
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    try:
+        # Translate document
+        result = translate_document(str(file_path), target_language)
+        
+        # Return results
+        return {
+            "filename": file.filename,
+            "target_language": target_language,
+            "translation": result
+        }
+    except Exception as e:
+        # Clean up file on error
+        if file_path.exists():
+            os.remove(file_path)
+        raise HTTPException(status_code=500, detail=str(e))
+
 # Add health check endpoint
 @app.get("/health")
 def health_check():

backend/modules/data_visualization.py

@@ -0,0 +1,49 @@
+import logging
+from pathlib import Path
+import json
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def generate_visualization(file_path: str, request: str) -> dict:
+    """
+    Generate visualization code for Excel data using Hugging Face models.
+    
+    Args:
+        file_path (str): Path to the Excel file
+        request (str): Natural language visualization request
+        
+    Returns:
+        dict: Generated code and visualization description
+    """
+    logger.info(f"Generating visualization for {file_path}: {request}")
+    
+    # Mock implementation - would use actual Hugging Face models in production
+    # Would actually read Excel data and generate real matplotlib/seaborn code
+    
+    # Example mock visualization code
+    mock_code = """
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Read the Excel file
+df = pd.read_excel('data.xlsx')
+
+# Create the visualization
+plt.figure(figsize=(10, 6))
+sns.barplot(data=df, x='Category', y='Values')
+plt.title('Data Visualization')
+plt.xlabel('Categories')
+plt.ylabel('Values')
+plt.xticks(rotation=45)
+plt.tight_layout()
+plt.show()
+"""
+    
+    return {
+        "code": mock_code,
+        "description": "This code generates a bar plot showing the relationship between categories and their corresponding values from your Excel data.",
+        "note": "This is a mock response. In production, the code would be generated based on actual Excel data analysis and user requirements."
+    }

backend/modules/question_answering.py

@@ -0,0 +1,32 @@
+import logging
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def process_question(file_path: str, question: str) -> str:
+    """
+    Process a question about a document or image using Hugging Face models.
+    
+    Args:
+        file_path (str): Path to the document or image
+        question (str): User's question
+        
+    Returns:
+        str: Answer to the question
+    """
+    logger.info(f"Processing question for {file_path}: {question}")
+    
+    # Mock implementation - would use actual Hugging Face models in production
+    # Example models: deepseek-ai/DeepSeek-V2-Chat or meta-llama/Llama-2-70b-chat-hf
+    
+    file_ext = Path(file_path).suffix.lower()
+    
+    # Generate mock response based on file type
+    if file_ext in ['.pdf', '.docx', '.pptx', '.xlsx', '.xls']:
+        return f"Based on the document content, the answer to '{question}' is: This is a mock response that would be generated by an actual language model in production."
+    elif file_ext in ['.jpg', '.jpeg', '.png']:
+        return f"Looking at the image, in response to '{question}': This is a mock response that would be generated by a vision-language model in production."
+    else:
+        return "Unsupported file type for question answering."

backend/modules/translator.py

@@ -0,0 +1,35 @@
+import logging
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def translate_document(file_path: str, target_language: str) -> str:
+    """
+    Translate document content using Hugging Face models.
+    
+    Args:
+        file_path (str): Path to the document
+        target_language (str): Target language code (e.g., 'fr', 'es', 'de')
+        
+    Returns:
+        str: Translated content
+    """
+    logger.info(f"Translating document {file_path} to {target_language}")
+    
+    # Mock implementation - would use actual Hugging Face models in production
+    
+    file_ext = Path(file_path).suffix.lower()
+    
+    # Mock translation based on file type
+    if file_ext == '.pdf':
+        return f"This is a mock translation of a PDF document to {target_language}. In production, this would be actual translated content."
+    elif file_ext == '.docx':
+        return f"This is a mock translation of a Word document to {target_language}. In production, this would be actual translated content."
+    elif file_ext == '.pptx':
+        return f"This is a mock translation of a PowerPoint presentation to {target_language}. In production, this would be actual translated content."
+    elif file_ext in ['.xlsx', '.xls']:
+        return f"This is a mock translation of Excel content to {target_language}. In production, this would be actual translated content."
+    else:
+        return "Unsupported file type for translation."

backend/requirements.txt

@@ -4,4 +4,7 @@ python-multipart==0.0.6
 aiofiles==23.2.1
 Pillow==10.0.1
 pydantic==2.4.2
-python-dotenv==1.0.0
+python-dotenv==1.0.0
+pandas==2.1.1
+matplotlib==3.8.0
+seaborn==0.13.0