refactor: improve code readability and structure in OpenAI integration tests and services, update requirements for consistency

backend/app/api/v1/endpoints/chat.py

@@ -1,94 +1,101 @@
-import os
-import json
-
-from fastapi import APIRouter, HTTPException
-from fastapi.responses import StreamingResponse
-import openai
-from typing import List
-
-from ....schemas.chat import Message, ChatRequest
-from ....core.config import settings
-
-router = APIRouter(prefix="/chat", tags=["chat"])
-
-# Initialize OpenAI client using the same settings as other working endpoints
-client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
-
-
-async def stream_text(messages: List[Message]):
-    try:
-        formatted_messages = [
-            {"role": "system", "content": """You are an AI learning assistant for PlayGo AI, 
-             an educational platform. Your goal is to help students learn and understand various 
-             subjects. Provide clear, concise, and accurate explanations."""},
-        ] + [{"role": msg.role, "content": msg.content} for msg in messages]
-
-        stream = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=formatted_messages,
-            temperature=0.7,
-            stream=True
-        )
-
-        for chunk in stream:
-            for choice in chunk.choices:
-                if choice.finish_reason == "stop":
-                    continue
-
-                else:
-                    yield '0:{text}\n'.format(text=json.dumps(choice.delta.content))
-
-            if chunk.choices == []:
-                usage = chunk.usage
-                prompt_tokens = usage.prompt_tokens
-                completion_tokens = usage.completion_tokens
-                yield 'd:{{"finishReason":"{reason}","usage":{{"promptTokens":{prompt},"completionTokens":{completion}}}}}\n'.format(
-                    reason="stop",
-                    prompt=prompt_tokens,
-                    completion=completion_tokens
-                )
-
-    except Exception as e:
-        print(f"Error in stream_text: {str(e)}")
-        yield f"Error: {str(e)}".encode('utf-8')
-
-
-@router.post("/stream")
-async def chat_stream(request: ChatRequest):
-    response = StreamingResponse(
-        stream_text(request.messages),
-    )
-    response.headers['x-vercel-ai-data-stream'] = 'v1'
-    return response
-
-
-@router.get("/test")
-async def test_chat():
-    return {"message": "Chat endpoint is working!"}
-
-
-@router.get("/test-simple")
-async def test_simple_chat():
-    """Test simple chat completion without streaming - same as working repo"""
-    try:
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "user", "content": "Say 'Hello from simple chat!' in exactly those words."}
-            ],
-            max_tokens=20
-        )
-        
-        return {
-            "status": "success",
-            "message": "Simple chat works!",
-            "response": response.choices[0].message.content,
-            "model": response.model
-        }
-        
-    except Exception as e:
-        return {
-            "status": "error", 
-            "message": f"Simple chat failed: {str(e)}",
-            "error_type": type(e).__name__
-        } 
+# import os
+# import json
+
+# from fastapi import APIRouter, HTTPException
+# from fastapi.responses import StreamingResponse
+# import openai
+# from typing import List
+
+# from ....schemas.chat import Message, ChatRequest
+# from ....core.config import settings
+
+# router = APIRouter(prefix="/chat", tags=["chat"])
+
+# # Initialize OpenAI client using the same settings as other working endpoints
+# client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+
+
+# async def stream_text(messages: List[Message]):
+#     try:
+#         formatted_messages = (
+#             [
+#                 {
+#                     "role": "system",
+#                     "content": """You are an AI learning assistant for PlayGo AI, 
+#              an educational platform. Your goal is to help students learn and understand various 
+#              subjects. Provide clear, concise, and accurate explanations.""",
+#                 },
+#             ]
+#             + [{"role": msg.role, "content": msg.content} for msg in messages]
+#         )
+
+#         stream = client.chat.completions.create(
+#             model="gpt-3.5-turbo",
+#             messages=formatted_messages,
+#             temperature=0.7,
+#             stream=True,
+#         )
+
+#         for chunk in stream:
+#             for choice in chunk.choices:
+#                 if choice.finish_reason == "stop":
+#                     continue
+
+#                 else:
+#                     yield "0:{text}\n".format(text=json.dumps(choice.delta.content))
+
+#             if chunk.choices == []:
+#                 usage = chunk.usage
+#                 prompt_tokens = usage.prompt_tokens
+#                 completion_tokens = usage.completion_tokens
+#                 yield 'd:{{"finishReason":"{reason}","usage":{{"promptTokens":{prompt},"completionTokens":{completion}}}}}\n'.format(
+#                     reason="stop", prompt=prompt_tokens, completion=completion_tokens
+#                 )
+
+#     except Exception as e:
+#         print(f"Error in stream_text: {str(e)}")
+#         yield f"Error: {str(e)}".encode("utf-8")
+
+
+# @router.post("/stream")
+# async def chat_stream(request: ChatRequest):
+#     response = StreamingResponse(
+#         stream_text(request.messages),
+#     )
+#     response.headers["x-vercel-ai-data-stream"] = "v1"
+#     return response
+
+
+# @router.get("/test")
+# async def test_chat():
+#     return {"message": "Chat endpoint is working!"}
+
+
+# @router.get("/test-simple")
+# async def test_simple_chat():
+#     """Test simple chat completion without streaming - same as working repo"""
+#     try:
+#         response = client.chat.completions.create(
+#             model="gpt-3.5-turbo",
+#             messages=[
+#                 {
+#                     "role": "user",
+#                     "content": "Say 'Hello from simple chat!' in exactly those words.",
+#                 }
+#             ],
+#             max_tokens=20,
+#         )
+
+#         return {
+#             "status": "success",
+#             "message": "Simple chat works!",
+#             "response": response.choices[0].message.content,
+#             "model": response.model,
+#         }
+
+#     except Exception as e:
+#         return {
+#             "status": "error",
+#             "message": f"Simple chat failed: {str(e)}",
+#             "error_type": type(e).__name__,
+#         }

backend/app/core/config.py

@@ -36,7 +36,7 @@ class Settings(BaseSettings):
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
 
     # OpenAI settings
-    OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY")
+    OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY", "")
 
     class Config:
         env_file = ".env"

backend/app/main.py

@@ -72,67 +72,71 @@ async def health_check():
 
 
 # OpenAI connection test endpoint
-@app.get("/api/test-openai")
-async def test_openai():
-    """Test OpenAI connection without making actual API calls"""
-    try:
-        from .core.config import settings
-        
-        if not settings.OPENAI_API_KEY:
-            return {"status": "error", "message": "OPENAI_API_KEY not configured"}
-        
-        api_key_preview = (
-            settings.OPENAI_API_KEY[:10] + "..."
-            if len(settings.OPENAI_API_KEY) > 10
-            else "Too short"
-        )
-        
-        return {
-            "status": "ok", 
-            "message": "OpenAI API key is configured",
-            "api_key_preview": api_key_preview,
-            "environment": (
-                "production" if os.getenv("NODE_ENV") == "production" else "development"
-            ),
-        }
-    except Exception as e:
-        return {"status": "error", "message": f"OpenAI configuration error: {str(e)}"}
+# @app.get("/api/test-openai")
+# async def test_openai():
+#     """Test OpenAI connection without making actual API calls"""
+#     try:
+#         from .core.config import settings
+
+#         if not settings.OPENAI_API_KEY:
+#             return {"status": "error", "message": "OPENAI_API_KEY not configured"}
+
+#         api_key_preview = (
+#             settings.OPENAI_API_KEY[:10] + "..."
+#             if len(settings.OPENAI_API_KEY) > 10
+#             else "Too short"
+#         )
+
+#         return {
+#             "status": "ok",
+#             "message": "OpenAI API key is configured",
+#             "api_key_preview": api_key_preview,
+#             "environment": (
+#                 "production" if os.getenv("NODE_ENV") == "production" else "development"
+#             ),
+#         }
+#     except Exception as e:
+#         return {"status": "error", "message": f"OpenAI configuration error: {str(e)}"}
+
 
 # Test chat completions endpoint
-@app.get("/api/test-chat")
-async def test_chat():
-    """Test if OpenAI chat completions work on Hugging Face"""
-    try:
-        from .core.config import settings
-        from openai import OpenAI
-        
-        if not settings.OPENAI_API_KEY:
-            return {"status": "error", "message": "OPENAI_API_KEY not configured"}
-        
-        client = OpenAI(api_key=settings.OPENAI_API_KEY, timeout=30.0)
-        
-        # Test a simple chat completion
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "user", "content": "Say 'Hello from Hugging Face!' in exactly those words."}
-            ],
-            max_tokens=20
-        )
-        
-        return {
-            "status": "success",
-            "message": "Chat completions work!",
-            "response": response.choices[0].message.content,
-            "model": response.model
-        }
-        
-    except Exception as e:
-        return {
-            "status": "error", 
-            "message": f"Chat completion failed: {str(e)}",
-            "error_type": type(e).__name__
-        }
+# @app.get("/api/test-chat")
+# async def test_chat():
+#     """Test if OpenAI chat completions work on Hugging Face"""
+#     try:
+#         from .core.config import settings
+#         from openai import OpenAI
+
+#         if not settings.OPENAI_API_KEY:
+#             return {"status": "error", "message": "OPENAI_API_KEY not configured"}
+
+#         client = OpenAI(api_key=settings.OPENAI_API_KEY, timeout=30.0)
+
+#         # Test a simple chat completion
+#         response = client.chat.completions.create(
+#             model="gpt-3.5-turbo",
+#             messages=[
+#                 {
+#                     "role": "user",
+#                     "content": "Say 'Hello from Hugging Face!' in exactly those words.",
+#                 }
+#             ],
+#             max_tokens=20,
+#         )
+
+#         return {
+#             "status": "success",
+#             "message": "Chat completions work!",
+#             "response": response.choices[0].message.content,
+#             "model": response.model,
+#         }
+
+#     except Exception as e:
+#         return {
+#             "status": "error",
+#             "message": f"Chat completion failed: {str(e)}",
+#             "error_type": type(e).__name__,
+#         }
 
 
 # Include API router

backend/app/schemas/chat.py

@@ -8,4 +8,4 @@ class Message(BaseModel):
 
 
 class ChatRequest(BaseModel):
-    messages: List[Message] 
+    messages: List[Message]

backend/app/services/image_service.py

@@ -14,21 +14,8 @@ class ImageGenerationService:
     """Service for handling OpenAI image generation"""
 
     def __init__(self):
-        # Validate API key exists
-        if not settings.OPENAI_API_KEY:
-            logger.error("OPENAI_API_KEY not found in environment variables")
-            raise ValueError("OPENAI_API_KEY is required")
-
-        # Log API key status (first few characters only for security)
-        api_key_preview = (
-            settings.OPENAI_API_KEY[:10] + "..."
-            if settings.OPENAI_API_KEY
-            else "Not set"
-        )
-        logger.info(f"OpenAI API Key status: {api_key_preview}")
-
         self.client = OpenAI(
-            api_key=settings.OPENAI_API_KEY,
+            api_key=os.getenv("OPENAI_API_KEY"),
             timeout=60.0,  # Increase timeout for Hugging Face environment
             max_retries=2,  # Reduce retries to fail faster
         )
@@ -40,7 +27,9 @@ class ImageGenerationService:
         if not os.path.exists(self.output_dir):
             os.makedirs(self.output_dir)
 
-    async def _fallback_to_dalle(self, prompt: str, size: str, n: int, model: str) -> dict:
+    async def _fallback_to_dalle(
+        self, prompt: str, size: str, n: int, model: str
+    ) -> dict:
         """
         Fallback to regular DALL-E when responses API is blocked
         This sacrifices reference image capability but ensures the app works on Hugging Face
@@ -205,7 +194,9 @@ class ImageGenerationService:
 
                 if not generated_filenames:
                     # If responses API failed due to network restrictions, try fallback to regular DALL-E
-                    logger.warning("Responses API failed, attempting fallback to regular DALL-E")
+                    logger.warning(
+                        "Responses API failed, attempting fallback to regular DALL-E"
+                    )
                     return await self._fallback_to_dalle(prompt, size, n, model)
 
                 logger.info(

backend/requirements.txt

@@ -3,4 +3,5 @@ uvicorn>=0.15.0
 pydantic>=1.8.0
 python-dotenv>=0.19.0
 openai>=1.0.0
-python-dotenv>=0.19.0
+python-dotenv>=0.19.0
+pydantic-settings>=2.0.3

test_openai.py

@@ -9,7 +9,7 @@ print("=" * 40)
 
 # Load environment
 load_dotenv()
-api_key = os.getenv('OPENAI_API_KEY')
+api_key = os.getenv("OPENAI_API_KEY")
 
 print(f"1. API Key configured: {'✅ Yes' if api_key else '❌ No'}")
 if api_key:
@@ -19,9 +19,12 @@ if api_key:
 print("\n2. Testing basic HTTP connectivity...")
 try:
     import requests
-    response = requests.get('https://api.openai.com/v1/models', 
-                          headers={'Authorization': f'Bearer {api_key}'}, 
-                          timeout=30)
+
+    response = requests.get(
+        "https://api.openai.com/v1/models",
+        headers={"Authorization": f"Bearer {api_key}"},
+        timeout=30,
+    )
     print(f"   Status: {response.status_code}")
     if response.status_code == 200:
         print("   ✅ Direct HTTP request works!")
@@ -34,12 +37,13 @@ except Exception as e:
 print("\n3. Testing OpenAI library (simple config)...")
 try:
     from openai import OpenAI
+
     client = OpenAI(api_key=api_key)
-    
+
     response = client.chat.completions.create(
         model="gpt-3.5-turbo",
         messages=[{"role": "user", "content": "Say 'test'"}],
-        max_tokens=5
+        max_tokens=5,
     )
     print("   ✅ OpenAI library works!")
     print(f"   Response: {response.choices[0].message.content}")
@@ -51,16 +55,13 @@ except Exception as e:
 print("\n4. Testing OpenAI library (with timeout)...")
 try:
     from openai import OpenAI
-    client = OpenAI(
-        api_key=api_key,
-        timeout=60.0,
-        max_retries=2
-    )
-    
+
+    client = OpenAI(api_key=api_key, timeout=60.0, max_retries=2)
+
     response = client.chat.completions.create(
         model="gpt-3.5-turbo",
         messages=[{"role": "user", "content": "Say 'test'"}],
-        max_tokens=5
+        max_tokens=5,
     )
     print("   ✅ OpenAI library with timeout works!")
     print(f"   Response: {response.choices[0].message.content}")
@@ -68,4 +69,4 @@ except Exception as e:
     print(f"   ❌ OpenAI library with timeout error: {str(e)}")
     print(f"   Error type: {type(e).__name__}")
 
-print("\n🏁 Debug complete!") 
+print("\n🏁 Debug complete!")