Merge pull request #9 from Promptly-Technologies-LLC/5-test-and-hook-up-warnings-component

Use Depends to create client in API endpoints

Author: chriscarrollsmith

routers/files.py

@@ -1,7 +1,7 @@
 import os
 import logging
 from dotenv import load_dotenv
-from fastapi import APIRouter, Request, UploadFile, File, HTTPException
+from fastapi import APIRouter, Request, UploadFile, File, HTTPException, Depends
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 from openai import AsyncOpenAI
@@ -14,9 +14,6 @@
 
 router: APIRouter = APIRouter(prefix="/assistants/{assistant_id}/files", tags=["assistants_files"])
 
-# Initialize OpenAI client
-openai: AsyncOpenAI = AsyncOpenAI()
-
 # Pydantic model for DELETE request body
 class DeleteRequest(BaseModel):
     fileId: str
@@ -26,13 +23,13 @@ class FileParams(BaseModel):
     file_id: str
 
 # Helper function to get or create a vector store
-async def get_or_create_vector_store(assistantId: str) -> str:
-    assistant = await openai.beta.assistants.retrieve(assistantId)
+async def get_or_create_vector_store(assistantId: str, client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())) -> str:
+    assistant = await client.beta.assistants.retrieve(assistantId)
     if assistant.tool_resources and assistant.tool_resources.file_search and assistant.tool_resources.file_search.vector_store_ids:
         return assistant.tool_resources.file_search.vector_store_ids[0]
 
-    vector_store = await openai.beta.vectorStores.create(name="sample-assistant-vector-store")
-    await openai.beta.assistants.update(assistantId, {
+    vector_store = await client.beta.vectorStores.create(name="sample-assistant-vector-store")
+    await client.beta.assistants.update(assistantId, {
         "tool_resources": {
             "file_search": {
                 "vector_store_ids": [vector_store.id],
@@ -43,13 +40,13 @@ async def get_or_create_vector_store(assistantId: str) -> str:
 
 
 @router.get("/files/{file_id}")
-async def get_file(file_id: str):
+async def get_file(file_id: str, client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())):
     """
     Endpoint to download a file by file ID.
     """
     try:
         # Retrieve file metadata and content concurrently
-        file, file_content = await openai.files.retrieve(file_id), await openai.files.content(file_id)
+        file, file_content = await client.files.retrieve(file_id), await client.files.content(file_id)
 
         # Return the file content as a streaming response
         return StreamingResponse(
@@ -62,28 +59,28 @@ async def get_file(file_id: str):
 
 
 @router.post("/upload")
-async def upload_file(file: UploadFile = File(...)):
+async def upload_file(file: UploadFile = File(...), client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())):
     # Process file and upload to OpenAI
-    vector_store_id = await get_or_create_vector_store()
-    openai_file = await openai.files.create(
+    vector_store_id = await get_or_create_vector_store(assistant_id, client)
+    openai_file = await client.files.create(
         file=file.file,
         purpose="assistants"
     )
-    await openai.beta.vectorStores.files.create(vector_store_id, {
+    await client.beta.vectorStores.files.create(vector_store_id, {
         "file_id": openai_file.id
     })
     return {"message": "File uploaded successfully"}
 
 @router.get("/files")
-async def list_files():
+async def list_files(client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())):
     # List files in the vector store
-    vector_store_id = await get_or_create_vector_store()
-    file_list = await openai.beta.vectorStores.files.list(vector_store_id)
+    vector_store_id = await get_or_create_vector_store(assistant_id, client)
+    file_list = await client.beta.vectorStores.files.list(vector_store_id)
 
     files_array = []
     for file in file_list.data:
-        file_details = await openai.files.retrieve(file.id)
-        vector_file_details = await openai.beta.vectorStores.files.retrieve(vector_store_id, file.id)
+        file_details = await client.files.retrieve(file.id)
+        vector_file_details = await client.beta.vectorStores.files.retrieve(vector_store_id, file.id)
         files_array.append({
             "file_id": file.id,
             "filename": file_details.filename,
@@ -93,10 +90,10 @@ async def list_files():
     return files_array
 
 @router.delete("/delete")
-async def delete_file(request: Request):
+async def delete_file(request: Request, client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())):
     # Delete file from vector store
     body = await request.json()
     delete_request = DeleteRequest(**body)
-    vector_store_id = await get_or_create_vector_store()
-    await openai.beta.vectorStores.files.delete(vector_store_id, delete_request.fileId)
+    vector_store_id = await get_or_create_vector_store(assistant_id, client)
+    await client.beta.vectorStores.files.delete(vector_store_id, delete_request.fileId)
     return {"message": "File deleted successfully"}

routers/messages.py

@@ -1,7 +1,7 @@
 import os
 import logging
 from dotenv import load_dotenv
-from fastapi import APIRouter, Request, Form, HTTPException
+from fastapi import APIRouter, Form, HTTPException, Depends
 from fastapi.responses import StreamingResponse
 from openai import AsyncOpenAI
 from openai.resources.beta.threads.runs.runs import AsyncAssistantStreamManager
@@ -10,29 +10,22 @@
 
 logger: logging.Logger = logging.getLogger("uvicorn.error")
 
-# Get the assistant ID from .env file
-load_dotenv()
-assistant_id: str = os.getenv("ASSISTANT_ID")
-
 # Initialize the router
 router: APIRouter = APIRouter()
 
-# Initialize the OpenAI client
-openai: AsyncOpenAI = AsyncOpenAI()
-
 # Send a new message to a thread
 @router.post("/send_message")
 async def post_message(
-    request: Request,
     userInput: str = Form(...),
-    thread_id: str | None = Form(None)
+    thread_id: str | None = Form(None),
+    client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())
 ) -> dict:
     # Create a new assistant chat thread if no thread ID is provided
     if not thread_id or thread_id == "None" or thread_id == "null":
         thread_id: str = await create_thread()
 
     # Create a new message in the thread
-    await openai.beta.threads.messages.create(
+    await client.beta.threads.messages.create(
         thread_id=thread_id,
         role="user",
         content=userInput
@@ -42,17 +35,17 @@ async def post_message(
 
 @router.get("/stream_response")
 async def stream_response(
-    request: Request,
     thread_id: str | None = None,
+    client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())
 ) -> StreamingResponse:
     if not thread_id:
         raise HTTPException(status_code=400, message="thread_id is required")
 
     # Create a generator to stream the response from the assistant
-    # Create a generator to stream the response from the assistant
+    load_dotenv()
     async def event_generator():
-        stream: AsyncAssistantStreamManager = openai.beta.threads.runs.stream(
-            assistant_id=assistant_id,
+        stream: AsyncAssistantStreamManager = client.beta.threads.runs.stream(
+            assistant_id=os.getenv("ASSISTANT_ID"),
             thread_id=thread_id
         )
         async with stream as stream_manager:

routers/tools.py

@@ -1,28 +1,26 @@
 import logging
 from typing import Any
-from fastapi import APIRouter, Request, HTTPException
+from fastapi import APIRouter, Request, HTTPException, Depends
 from pydantic import BaseModel
 from openai import AsyncOpenAI
 
 logger = logging.getLogger("uvicorn.error")
 
 router = APIRouter()
 
-openai = AsyncOpenAI()
-
 class ToolCallOutputs(BaseModel):
     tool_outputs: Any
     runId: str
 
 @router.post("/send_tool_outputs")
-async def post_tool_outputs(thread_id: str, request: Request):
+async def post_tool_outputs(thread_id: str, request: Request, client: AsyncOpenAI = Depends(lambda: AsyncOpenAI())):
     try:
         # Parse the JSON body into the ToolCallOutputs model
         data = await request.json()
         tool_call_outputs = ToolCallOutputs(**data)
 
         # Submit tool outputs stream
-        stream = await openai.beta.threads.runs.submit_tool_outputs_stream(
+        stream = await client.beta.threads.runs.submit_tool_outputs_stream(
             thread_id,
             tool_call_outputs.runId,
             {"tool_outputs": tool_call_outputs.tool_outputs}