Refactor code structure and improve organization

api/index.py

@@ -1 +1,29 @@
-from app.main import app
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+# Absolute import from the project root
+from app.api.routes.recommendations import router as recommendations_router
+
+# This file is now the main entry point
+app = FastAPI(
+    title="Student Recommendation API",
+    description="API for student internship recommendations",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # Allow all origins
+    allow_credentials=True,
+    allow_methods=["*"], # Allow all methods
+    allow_headers=["*"], # Allow all headers
+)
+
+@app.get("/", tags=["Root"])
+async def read_root():
+    """A simple endpoint to confirm the API is running."""
+    return {"message": "Welcome to the Student Recommendation API!"}
+
+# Include the routes from your recommendations module
+app.include_router(recommendations_router, prefix="/api")
+
+# The Vercel server will discover and run this 'app' object.

app/api/routes/recommendations.py

@@ -1,15 +1,28 @@
-from fastapi import APIRouter
-from ...schemas.recommendation import ProfileRequest, RecommendationRequest
-from ...services import ranking
+from fastapi import APIRouter, HTTPException
+# --- Use absolute imports from 'app' ---
+from app.schemas.recommendation import RecommendationRequest, RecommendationResponse, CategoryResponse
+from app.services.ranking import get_ranked_internships, get_category_prediction
 
 router = APIRouter()
 
-@router.post("/predict-category", tags=["Predictions"])
-def predict_category(request: ProfileRequest):
-    category = ranking.get_category_prediction(request.profile_text)
-    return {"predicted_category": category}
+@router.post("/predict-category", response_model=CategoryResponse)
+def predict_category(request: RecommendationRequest):
+    """Predicts the job category based on the user's profile text."""
+    try:
+        predicted_category = get_category_prediction(request.profile_text)
+        return CategoryResponse(predicted_category=predicted_category)
+    except Exception as e:
+        # Log the error for debugging
+        print(f"Error in /predict-category: {e}")
+        raise HTTPException(status_code=500, detail="An error occurred during category prediction.")
 
-@router.post("/recommend-internships", tags=["Predictions"])
-def recommend_internships(request: RecommendationRequest):
-    ranked_ids = ranking.get_ranked_internships(request)
-    return {"recommendations": ranked_ids}
+@router.post("/rank-internships", response_model=RecommendationResponse)
+def rank_internships(request: RecommendationRequest):
+    """Ranks internships based on user profile and preferences."""
+    try:
+        ranked_ids = get_ranked_internships(request)
+        return RecommendationResponse(ranked_internship_ids=ranked_ids)
+    except Exception as e:
+        # Log the error for debugging
+        print(f"Error in /rank-internships: {e}")
+        raise HTTPException(status_code=500, detail="An error occurred during internship ranking.")

app/main.py

@@ -1,14 +0,0 @@
-from fastapi import FastAPI
-from .api.routes import recommendations
-
-app = FastAPI(
-    title="Student Recommendation API",
-    description="An API that uses machine learning to predict job categories and recommend internships.",
-    version="1.0.0"
-)
-
-app.include_router(recommendations.router, prefix="/api/v1")
-
-@app.get("/", tags=["Root"])
-def read_root():
-    return {"message": "Welcome to the Student Recommendation API"}

app/services/ranking.py

@@ -1,127 +1,82 @@
+# app/services/ranking.py
+
 from geopy.distance import geodesic
 import json
 import os
 from geopy.geocoders import Nominatim
 
-from ..core.models import load_all_models, tfidf_vectorizer, le, rf_model, sentence_model
-from ..schemas.recommendation import RecommendationRequest
-from ..utils.text import clean_resume
+# --- Use absolute imports from 'app' ---
+from app.core.models import load_all_models, tfidf_vectorizer, le, rf_model, sentence_model
+from app.schemas.recommendation import RecommendationRequest
+from app.utils.text import clean_resume
 
-geolocator = Nominatim(user_agent="student_recommendation_api_v1")
+print("--- Loading app/services/ranking.py module ---")
 
+# This geo-caching logic is fine
+geolocator = Nominatim(user_agent="student_recommendation_api_v1")
 GEO_CACHE_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "GEO_CACHE.txt")
 GEO_CACHE = {}
+_geo_cache_loaded = False
 
 def load_geo_cache():
-    global GEO_CACHE
+    global GEO_CACHE, _geo_cache_loaded
+    if _geo_cache_loaded: return
     if os.path.exists(GEO_CACHE_FILE):
         with open(GEO_CACHE_FILE, "r") as f:
-            try:
-                GEO_CACHE = json.load(f)
-            except json.JSONDecodeError:
-                GEO_CACHE = {}
+            try: GEO_CACHE = json.load(f)
+            except json.JSONDecodeError: GEO_CACHE = {}
+    _geo_cache_loaded = True
 
 def save_geo_cache():
-    with open(GEO_CACHE_FILE, "w") as f:
-        json.dump(GEO_CACHE, f)
-
-load_geo_cache()
+    with open(GEO_CACHE_FILE, "w") as f: json.dump(GEO_CACHE, f)
 
 def geo_coords(city_name: str) -> tuple | None:
-    """
-    Geocodes a city name to (latitude, longitude).
-    Uses an in-memory cache to avoid repeated API calls.
-    """
+    load_geo_cache()
     city_name = city_name.lower().strip()
-    if city_name in GEO_CACHE:
-        return GEO_CACHE[city_name]
+    if city_name in GEO_CACHE: return GEO_CACHE[city_name]
     try:
-        print(f"--- Geocoding and caching new city: {city_name} ---")
         location = geolocator.geocode(f"{city_name}, Indonesia")
-
         if location:
             coords = (location.latitude, location.longitude)
             GEO_CACHE[city_name] = coords
             save_geo_cache()
             return coords
         else:
-            print(f"Location not found for {city_name}")
             GEO_CACHE[city_name] = None
             save_geo_cache()
             return None
-    except Exception as e:
-        print(f"Error geocoding {city_name}: {e}")
-        return None
+    except Exception: return None
 
 def get_category_prediction(profile_text: str) -> str:
-    """Processes text and predicts the job category."""
-    if rf_model is None:
-        load_all_models()
-
+    if rf_model is None: load_all_models()
     cleaned_text = profile_text.lower()
     vectorized_text = tfidf_vectorizer.transform([cleaned_text])
     prediction_encoded = rf_model.predict(vectorized_text)[0]
     category = le.inverse_transform([prediction_encoded])[0]
     return category
 
-def  get_ranked_internships(request: RecommendationRequest) -> list[int]:
-    """Performs two-stage ranking with dynamic geocoding."""
-
-    if sentence_model is None:
-        load_all_models()
-
+def get_ranked_internships(request: RecommendationRequest) -> list[int]:
+    if sentence_model is None: load_all_models()
     profile_text_to_encode = request.profile_text
-
     if request.predicted_category:
         profile_text_to_encode = f"The user's predicted job category is {request.predicted_category}. Based on that, consider their profile: {request.profile_text}"
-
     profile_embedding = sentence_model.encode(profile_text_to_encode)
     internship_texts = [internship.internship_text for internship in request.internships]
-
-    if not internship_texts:
-        return []
-
+    if not internship_texts: return []
     internship_embeddings = sentence_model.encode(internship_texts)
     cosine_score = sentence_model.similarity(profile_embedding, internship_embeddings)[0].tolist()
-
-    print("--- FastAPI Debugging ---")
-    print(f"Received {len(internship_texts)} internships to rank.")
-    print(f"Calculated Cosine Scores: {cosine_score}")
-    print("--------------------------")
-
-    ranked_by_similarity = []
-    for i, internship in enumerate(request.internships):
-        ranked_by_similarity.append({
-            "id": internship.id,
-            "similarity_score": cosine_score[i],
-            "location": internship.location,
-        })
-
+    ranked_by_similarity = [{"id": i.id, "similarity_score": s, "location": i.location} for i, s in zip(request.internships, cosine_score)]
     final_ranked_list = []
     user_coords = geo_coords(request.preferred_location)
-
-    print(user_coords, request.preferred_location)
-
-
     for internship in ranked_by_similarity:
         final_score = internship['similarity_score']
-
         if user_coords:
             internship_coords = geo_coords(internship['location'])
             if internship_coords:
                 distance_km = geodesic(user_coords, internship_coords).kilometers
-                if distance_km < 1:
-                    final_score += 2.0
-                elif distance_km < 150:
-                    final_score += 0.75
-
+                if distance_km < 1: final_score += 2.0
+                elif distance_km < 150: final_score += 0.75
         internship['final_score'] = final_score
         final_ranked_list.append(internship)
-
     final_ranked_list.sort(key=lambda x: x['final_score'], reverse=True)
-
-    final_ids = [item['id'] for item in final_ranked_list]
-
-    print(final_ranked_list)
-
-    return final_ids
+    return [item['id'] for item in final_ranked_list]