Update main.py

main.py

@@ -1,164 +1,111 @@
-from fastapi import FastAPI, HTTPException, Request, Query
-from fastapi.middleware.cors import CORSMiddleware
-# from fastapi_cache import FastAPICache
-# from fastapi_cache.backends.inmemory import InMemoryBackend
-# from fastapi_cache.decorator import cache
-from queue import Empty
-import os
-app = FastAPI()
-root_dir = os.getcwd()
-# @app.on_event("startup")
-# async def startup():
-#     FastAPICache.init(InMemoryBackend(), prefix="fastapi-cache")
-
-from pydantic import BaseModel
-from typing import List, Dict, Any
-
-TOGETHER_API_KEY = os.getenv('TOGETHER_API_KEY')
-BRAVE_API_KEY = os.getenv('BRAVE_API_KEY')
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-HELICON_API_KEY = os.getenv("HELICON_API_KEY")
-SUPABASE_USER = os.environ['SUPABASE_USER']
-SUPABASE_PASSWORD = os.environ['SUPABASE_PASSWORD']
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],)
-
-import asyncio
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException, Request, Depends
+from fastapi.responses import JSONResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel, HttpUrl
+from typing import Optional
 import uvicorn
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-from jupyter_client import KernelManager
-from typing import Dict
-from datetime import datetime, timedelta
-import psutil
-
-# Model for input data
-class CodeExecutionRequest(BaseModel):
-    session_token: str
-    code: str
-
-# Store kernel managers and last access times
-kernel_managers: Dict[str, KernelManager] = {}
-last_access_times: Dict[str, datetime] = {}
-
-# Timeout duration in seconds
-TIMEOUT_DURATION = 600  # 10 minutes
-
-# Function to create a new kernel
-async def create_kernel(session_token: str):
-    km = KernelManager()
-    km.start_kernel()
-    kernel_managers[session_token] = km
-    last_access_times[session_token] = datetime.now()
-
-# Function to kill a kernel
-async def kill_kernel(session_token: str):
-    km = kernel_managers.pop(session_token, None)
-    if km:
-        km.shutdown_kernel(now=True)
-    last_access_times.pop(session_token, None)
-    
-    session_dir = os.path.join(root_dir, "output", session_token)
-    if os.path.exists(session_dir):
-        shutil.rmtree(session_dir)
-
-# Function to execute code in a kernel
-# Function to execute code in a kernel
-async def execute_code(session_token: str, code: str):
-    setup_code = "%matplotlib inline"
-    
-    session_dir = os.path.join(root_dir,"output", session_token)
-    
-    if not os.path.exists(session_dir):
-        os.makedirs(session_dir)
-    
-    if session_token not in kernel_managers:
-        await create_kernel(session_token)
-
-    km = kernel_managers[session_token]
-    kc = km.client()
-
+from fastapi.middleware.cors import CORSMiddleware
+from utils import read_file, fetch_job_description, optimize_resume_api
+import logging
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.inmemory import InMemoryBackend
+from fastapi_cache.decorator import cache
+import hashlib
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Resume Optimizer API")
+
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+security = HTTPBearer()
+
+class OptimizationResponse(BaseModel):
+    optimizedResume: str
+    metadata: dict
+
+class ErrorResponse(BaseModel):
+    detail: str
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    token = credentials.credentials
+    if token != "your_secret_token":
+        raise HTTPException(status_code=401, detail="Invalid authentication token")
+    return token
+
+def generate_cache_key(resume_content: str, job_description_content: str) -> str:
+    combined = resume_content + job_description_content
+    return hashlib.md5(combined.encode()).hexdigest()
+
+@app.post("/api/optimize-resume", response_model=OptimizationResponse, responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 500: {"model": ErrorResponse}})
+@cache(expire=36000000)  # Cache for n seconds
+async def optimize_resume(
+    resume: Optional[UploadFile] = File(None),
+    resumeText: Optional[str] = Form(None),
+    jobDescription: Optional[str] = Form(None),
+    jobDescriptionUrl: Optional[HttpUrl] = Form(None),
+    token: str = Depends(verify_token)
+):
     try:
-        os.chdir(session_dir)
-        print("current working directory",os.getcwd())
-        # Execute setup code
-        kc.execute_interactive(setup_code, store_history=False)
-        # Execute the provided code
-        kc.execute(code, store_history=False)
-
-        output = []
-        timeout = datetime.now() + timedelta(seconds=TIMEOUT_DURATION)
-
-        output = []
-        while True:
-            if datetime.now() > timeout:
-                raise TimeoutError("Code execution timed out.")
-                
-            msg = kc.get_iopub_msg()
-            if msg['msg_type'] == 'status' and msg['content']['execution_state'] == 'idle':
-                break
-            elif msg['msg_type'] == 'error':
-                error_output = {
-                    "ename": msg['content']['ename'],
-                    "evalue": msg['content']['evalue'],
-                    "traceback": msg['content']['traceback']
-                }
-                output.append({"error": error_output})
-            if 'data' in msg['content']:
-                output.append({"data": msg['content']['data']})
-            elif 'text' in msg['content']:
-                output.append({"text": msg['content']['text']})
-            
-        last_access_times[session_token] = datetime.now()
-        print("Execution SUCCESS")
-        print("#################")
-        print("CODE:",code)
-        print("OUTPUT:",output)
-        return {'status': 'success', 'value': output}
-
+        # Input validation
+        if (resume is None) == (resumeText is None):
+            raise ValueError("Provide either resume file or resume text, but not both")
+        if (jobDescription is None) == (jobDescriptionUrl is None):
+            raise ValueError("Provide either job description text or URL, but not both")
+        
+        # Process resume
+        if resume:
+            resume_content = read_file(resume)
+        else:
+            resume_content = resumeText
+        
+        # Process job description
+        if jobDescription:
+            job_description_content = jobDescription
+        else:
+            job_description_content = fetch_job_description(jobDescriptionUrl)
+
+        # Generate cache key
+        cache_key = generate_cache_key(resume_content, job_description_content)
+
+        # Check cache
+        cached_result = await FastAPICache.get(cache_key)
+        if cached_result:
+            return OptimizationResponse(**cached_result)
+
+        # Perform optimization
+        optimized_resume = optimize_resume_api(resume_content, job_description_content)
+
+        metadata = {
+            "original_resume": resume_content,
+            "original_jd": job_description_content
+        }
+
+        result = OptimizationResponse(
+            optimizedResume=optimized_resume,
+            metadata=metadata
+        )
+
+        # Cache the result
+        await FastAPICache.set(cache_key, result.dict(), expire=36000000)
+
+        return result
+    except ValueError as ve:
+        logger.error(f"ValueError occurred: {str(ve)}", exc_info=True)
+        raise HTTPException(status_code=400, detail=str(ve))
     except Exception as e:
-        last_access_times[session_token] = datetime.now()
-        return {'status': 'error', 'value': str(e)}
-
-
-# Background task to check for idle kernels
-async def check_idle_kernels():
-    while True:
-        now = datetime.now()
-        for session_token, last_access in list(last_access_times.items()):
-            if now - last_access > timedelta(seconds=TIMEOUT_DURATION):
-                await kill_kernel(session_token)
-        await asyncio.sleep(60)  # Check every minute
+        logger.error(f"Unexpected error occurred: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+    
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+    return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail})
 
 @app.on_event("startup")
-async def startup_event():
-    asyncio.create_task(check_idle_kernels())
-
-@app.post("/execute")
-async def execute(request: CodeExecutionRequest):
-    result = await execute_code(request.session_token, request.code)
-    return result
-
-@app.get("/info")
-async def get_info():
-    # Get the number of active kernels
-    active_kernels = len(kernel_managers)
-
-    # Get system resource usage
-    cpu_usage = psutil.cpu_percent(interval=1)
-    ram_usage = psutil.virtual_memory().percent
-
-    # Return the information
-    return {
-        "active_kernels": active_kernels,
-        "cpu_usage_percent": cpu_usage,
-        "ram_usage_percent": ram_usage
-    }
+async def startup():
+    FastAPICache.init(InMemoryBackend(), prefix="fastapi-cache")
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=8000, debug=True)