Update routers/powerpoint.py

routers/powerpoint.py

@@ -4,7 +4,6 @@ from pydantic import BaseModel
 from typing import Annotated, List, Literal, Optional, Union, Dict
 from google import genai
 from google.genai import types
-from mistralai import Mistral
 from auth import verify_token
 import os
 import tempfile
@@ -21,7 +20,6 @@ from collections import deque
 from threading import Lock
 import json
 from abc import ABC, abstractmethod
-import base64
 
 router = APIRouter(prefix="/powerpoint", tags=["powerpoint"])
 
@@ -29,10 +27,6 @@ router = APIRouter(prefix="/powerpoint", tags=["powerpoint"])
 gemini_key = os.environ.get('GEMINI_KEY', '')
 client = genai.Client(api_key=gemini_key)
 
-# Get Mistral client
-mistral_key = os.environ.get('MISTRAL_KEY', '')
-mistral_client = Mistral(api_key=mistral_key)
-
 class APIResponse(BaseModel):
     success: bool
     data: Optional[Union[Dict, List[Dict], str]] = None
@@ -49,10 +43,6 @@ class MultimodalModel(str, Enum):
     gemini_20_flash_lite = "gemini-2.0-flash-lite"
     gemini_25_pro = "gemini-2.5-pro"
 
-class MistralModel(str, Enum):
-    mistral_small_latest = "mistral-small-latest"
-    mistral_medium_latest = "mistral-medium-latest"
-
 class TemplateType(str, Enum):
     single_graph = "single_graph"
     two_column_graph = "two_column_graph"
@@ -562,109 +552,6 @@ async def image_to_pptx(
     except Exception as e:
         return APIResponse(success=False, error=f"Failed to generate presentation: {str(e)}")
 
-def get_mistral_json_schema(pydantic_model):
-    """Convert Pydantic model to Mistral-compatible JSON schema"""
-    schema = pydantic_model.model_json_schema()
-    
-    # Remove definitions and flatten the schema
-    if "$defs" in schema:
-        defs = schema.pop("$defs")
-        
-        def resolve_refs(obj):
-            if isinstance(obj, dict):
-                if "$ref" in obj:
-                    ref_path = obj["$ref"].split("/")[-1]
-                    if ref_path in defs:
-                        return resolve_refs(defs[ref_path])
-                    return obj
-                else:
-                    return {k: resolve_refs(v) for k, v in obj.items()}
-            elif isinstance(obj, list):
-                return [resolve_refs(item) for item in obj]
-            return obj
-        
-        schema = resolve_refs(schema)
-    
-    return schema
-
-@router.post("/mistral-image-to-pptx")
-async def mistral_image_to_pptx(
-    token: Annotated[str, Depends(verify_token)],
-    file: UploadFile = File(..., description="Image file to convert to PowerPoint"),
-    template: TemplateType = Form(..., description="Template type to use for the presentation"),
-    model: MistralModel = Form(..., description="Mistral model (mistral-small-latest or mistral-medium-latest)"),
-):
-    """
-    Analyze an image with Mistral AI and generate a PowerPoint presentation based on the analysis using the selected template
-    """
-    try:       
-        # Get template generator
-        template_generator = TEMPLATE_GENERATORS.get(template)
-        if not template_generator:
-            raise HTTPException(status_code=400, detail=f"Unsupported template: {template}")
-        
-        # Read uploaded file
-        file_content = await file.read()
-        
-        # Convert image to base64 for Mistral
-        image_base64 = base64.b64encode(file_content).decode('utf-8')
-        image_url = f"data:{file.content_type};base64,{image_base64}"
-        
-        # Prepare messages for Mistral
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": template_generator.get_prompt()
-                    },
-                    {
-                        "type": "image_url",
-                        "image_url": image_url
-                    }
-                ]
-            }
-        ]
-
-        # Get JSON schema for response format
-        response_schema = get_mistral_json_schema(template_generator.get_response_schema())
-        
-        # Send to Mistral
-        response = mistral_client.chat.complete(
-            model=model.value,
-            messages=messages,
-            response_format={
-                "type": "json_object",
-                "schema": response_schema
-            }
-        )
-        
-
-        # Display usage information
-        if hasattr(response, 'usage'):
-            print(f"Mistral usage: {response.usage}")
-        
-        # Parse the response
-        response_text = response.choices[0].message.content
-        print(response_text)
-        presentation_data = template_generator.get_response_schema().model_validate(json.loads(response_text))
-        
-        # Generate PPTX file
-        pptx_path = template_generator.generate_pptx(presentation_data)
-        
-        # Return file as download
-        return FileResponse(
-            path=pptx_path,
-            filename=f"mistral_presentation_{template.value}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pptx",
-            media_type="application/vnd.openxmlformats-officedocument.presentationml.presentation"
-        )
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        return APIResponse(success=False, error=f"Failed to generate presentation with Mistral: {str(e)}")
-
 @router.get("/templates")
 async def get_available_templates(token: Annotated[str, Depends(verify_token)]):
     """Get list of available presentation templates"""