path way edits

apiRoutes.py

@@ -1,13 +1,22 @@
 from fastapi import APIRouter, WebSocket, WebSocketDisconnect, UploadFile, File, HTTPException
 import json
 from fastapi.responses import JSONResponse
-from controllers.lettersControllerS import detectFromImageBytes as detectLetters
-from controllers.wordsControllerS import detectFromImageBytes as detectWords
+from lettersControllerS import detectFromImageBytes as detectLetters
+from wordsControllerS import detectFromImageBytes as detectWords
 from typing import List
 from dotenv import load_dotenv
 import httpx
 import os
 
+os.environ["HF_HOME"] = "/tmp" 
+os.environ["HUGGINGFACE_HUB_CACHE"] = "/tmp/huggingface_cache" 
+os.makedirs("/tmp/huggingface_cache", exist_ok=True) 
+# Ensure these imports are correct
+from lettersController import detectFromImage
+from wordsController import detectWords
+from glossController import translateGloss
+
+
 router = APIRouter(prefix="/handsUPApi")
 
 class ConnectionManager:
@@ -204,35 +213,54 @@ async def sendToHF(url: str, frames: List[UploadFile]):
 
 @router.post("/processLetters")
 async def process_letters(frames: List[UploadFile] = File(...)):
+    """Processes a sequence of frames to detect sign language letters."""
     sequence_num = 20
     if len(frames) != sequence_num:
-        raise HTTPException(status_code=400, detail=f"Exactly {sequence_num} frames required")
+        raise HTTPException(status_code=400, detail=f"Exactly {sequence_num} frames are required")
 
-    url = f"{HUGGINGFACE_BASE_URL}/detect-letters"
-
-    result = await sendToHF(url, frames)
-    print(f"Received result: {result}")
+    # CRITICAL: Read the binary content of each file
+    # We will pass a list of image bytes (memory buffers), NOT UploadFile objects.
+    image_bytes_list = []
+    try:
+        for frame in frames:
+            # frame.file is an async context manager, read() returns bytes
+            contents = await frame.read()
+            image_bytes_list.append(contents)
+    except Exception as e:
+        # Handle potential file read errors
+        raise HTTPException(status_code=500, detail=f"Error reading uploaded file contents: {e}")
+
+    # Pass the list of image bytes to the controller
+    result = detectFromImage(image_bytes_list)
     return JSONResponse(content=result)
 
-
 @router.post("/processWords")
 async def process_words(frames: List[UploadFile] = File(...)):
+    """Processes a sequence of frames to detect sign language words."""
     sequence_num = 90
     if len(frames) != sequence_num:
-        raise HTTPException(status_code=400, detail=f"Exactly {sequence_num} frames required")
-
-    url = f"{HUGGINGFACE_BASE_URL}/detect-words"
+        raise HTTPException(status_code=400, detail=f"Exactly {sequence_num} frames are required")
 
-    result = await sendToHF(url, frames)
+    # CRITICAL: Read the binary content of each file
+    image_bytes_list = []
+    try:
+        for frame in frames:
+            contents = await frame.read()
+            image_bytes_list.append(contents)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading uploaded file contents: {e}")
+
+    # Call the imported function directly
+    result = detectWords(image_bytes_list)
     return JSONResponse(content=result)
 
-
 @router.post("/sentence")
 async def sign_sentence(data: dict):
+    """Generates a signed sentence from a given gloss."""
     gloss_input = data.get("gloss")
     if not gloss_input:
         raise HTTPException(status_code=400, detail="No gloss provided")
 
-    from controllers.glossController import translateGloss
-    translation = translateGloss(gloss_input)
-    return {"translation": translation}
+    # Call the imported function directly
+    result = translateGloss(gloss_input)
+    return JSONResponse(content={"translation": result})

app.py

@@ -1,145 +1,15 @@
 import os
-import sys
-import uvicorn
-from fastapi import FastAPI, UploadFile, File, Form
-from typing import List
-from starlette.responses import JSONResponse
-import tempfile
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from apiRoutes import router as sign_router
 
-# Correct import statements for all controllers
-try:
-    from lettersController import detectFromImage
-    from wordsController import detectWords
-    from glossController import translateGloss
-    print("Successfully imported functions from controllers.")
-except ImportError as e:
-    print(f"ERROR: Could not import from controllers: {e}")
-    sys.exit(1)
-
-# --- FastAPI App Initialization ---
 app = FastAPI()
-
-# --- Load AI Model and Assets on Startup ---
-# The models are loaded when the controller modules are imported.
-# It's a good practice to print a message to confirm this.
-print("\n--- Hugging Face Space starting. Models are being loaded... ---")
-print("--- AI letter, words, and translation models loaded. Ready to serve predictions. ---\n")
-
-# --- FastAPI Route for Letter Detection ---
-@app.post("/detect-letters")
-async def process_letters(
-    frames: List[UploadFile] = File(...)
-):
-    """
-    Receives 20 image frames and processes them to detect a letter or number.
-    """
-    sequence_num = 20
-    if len(frames) != sequence_num:
-        return JSONResponse(
-            status_code=400,
-            content={"error": f"Exactly {sequence_num} frames are required for letter detection", "success": False}
-        )
-    
-    temp_dir = tempfile.mkdtemp()
-    paths = []
-
-    try:
-        # Save each frame to a temporary file
-        for i, frame in enumerate(frames):
-            path = os.path.join(temp_dir, f'frame_{i}.jpg')
-            contents = await frame.read()
-            with open(path, "wb") as f:
-                f.write(contents)
-            paths.append(path)
-
-        # Call the letter detection function
-        result = detectFromImage(paths)
-        
-        return JSONResponse(content=result)
-        
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={
-                "error": "Error processing image sequence for letter detection",
-                "details": str(e),
-                "success": False
-            }
-        )
-    finally:
-        # Clean up temporary files
-        for path in paths:
-            os.remove(path)
-        os.rmdir(temp_dir)
-
-# --- FastAPI Route for Word Detection ---
-@app.post("/detect-words")
-async def process_words(
-    frames: List[UploadFile] = File(...)
-):
-    """
-    Receives 90 image frames and processes them to detect a word.
-    """
-    sequence_length = 90
-    if len(frames) != sequence_length:
-        return JSONResponse(
-            status_code=400,
-            content={"error": f"Exactly {sequence_length} frames are required for word detection", "success": False}
-        )
-    
-    temp_dir = tempfile.mkdtemp()
-    paths = []
-
-    try:
-        # Save each frame to a temporary file
-        for i, frame in enumerate(frames):
-            path = os.path.join(temp_dir, f'frame_{i}.jpg')
-            contents = await frame.read()
-            with open(path, "wb") as f:
-                f.write(contents)
-            paths.append(path)
-
-        # Call the word detection function
-        result = detectWords(paths)
-        
-        return JSONResponse(content=result)
-        
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={
-                "error": "Error processing image sequence for word detection",
-                "details": str(e),
-                "success": False
-            }
-        )
-    finally:
-        # Clean up temporary files
-        for path in paths:
-            os.remove(path)
-        os.rmdir(temp_dir)
-
-# --- FastAPI Route for Sentence Translation ---
-@app.post("/sentence")
-async def process_sentence(
-    gloss: str = Form(...)
-):
-    """
-    Receives a string of gloss and translates it into a human-readable sentence.
-    """
-    try:
-        result = translateGloss(gloss)
-        return JSONResponse(content={"translation": result, "success": True})
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={
-                "error": "Error translating gloss",
-                "details": str(e),
-                "success": False
-            }
-        )
-
-if __name__ == "__main__":
-    # Hugging Face Spaces automatically sets the port to 7860
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+app.include_router(sign_router)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://handsup.onrender.com"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)

lettersControllerS.py

@@ -5,16 +5,16 @@ import tensorflow as tf
 import mediapipe as mp
 from fastapi import WebSocket
 
-lettersModel = tf.keras.models.load_model('../../ai_model/models/detectLettersModel.keras')
-with open('../../ai_model/models/labelEncoder.pickle', 'rb') as f:
+lettersModel = tf.keras.models.load_model('ai_model/models/detectLettersModel.keras')
+with open('ai_model/models/labelEncoder.pickle', 'rb') as f:
     labelEncoder = pickle.load(f)
 
-lettersModel2 = tf.keras.models.load_model('../../ai_model/jz_model/JZModel.keras')
-with open('../../ai_model/jz_model/labelEncoder.pickle', 'rb') as f:
+lettersModel2 = tf.keras.models.load_model('ai_model/jz_model/JZModel.keras')
+with open('ai_model/jz_model/labelEncoder.pickle', 'rb') as f:
     labelEncoder2 = pickle.load(f)
 
-numbersModel = tf.keras.models.load_model('../../ai_model/models/detectNumbersModel.keras')
-with open('../../ai_model/models/numLabelEncoder.pickle', 'rb') as f:
+numbersModel = tf.keras.models.load_model('ai_model/models/detectNumbersModel.keras')
+with open('ai_model/models/numLabelEncoder.pickle', 'rb') as f:
     numLabelEncoder = pickle.load(f)
 
 hands = mp.solutions.hands.Hands(static_image_mode=True)