Update app.py

app.py

@@ -11,7 +11,6 @@ from sklearn.feature_extraction.text import TfidfVectorizer
 from flask import Flask, request, jsonify
 import logging
 from pymongo import MongoClient
-import requests
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
@@ -23,7 +22,7 @@ os.environ["TOKENIZERS_PARALLELISM"] = "false"
 # MongoDB connection
 MONGO_URI = "mongodb://muhammadbinimran1001:[email protected]:27017,dsm-shard-00-01.inrzs.mongodb.net:27017,dsm-shard-00-02.inrzs.mongodb.net:27017/?ssl=true&replicaSet=atlas-nbg4er-shard-0&authSource=admin&retryWrites=true&w=majority"
 client = MongoClient(MONGO_URI)
-db = client.get_database("test")  # Adjust the database name as needed
+db = client.get_database("test")
 users_collection = db["users"]
 courses_collection = db["courses"]
 jobs_collection = db["jobs"]
@@ -62,7 +61,9 @@ course_similarity = None
 job_similarity = None
 
 # Improved dataset loading with fallback
-def load_dataset(file_path, required_columns=[], additional_columns=['popularity', 'completion_rate'], fallback_data=None):
+def load_dataset(file_path, required_columns=None, additional_columns=None, fallback_data=None):
+    required_columns = required_columns or ["Skill", "Question", "Answer"]
+    additional_columns = additional_columns or ['popularity', 'completion_rate']
     try:
         df = pd.read_csv(file_path)
         missing_required = [col for col in required_columns if col not in df.columns]
@@ -76,35 +77,21 @@ def load_dataset(file_path, required_columns=[], additional_columns=['popularity
         if missing_additional:
             logger.warning(f"Additional columns {missing_additional} missing in {file_path}. Adding default values.")
             for col in missing_additional:
-                if col == 'popularity':
-                    df[col] = 0.8
-                elif col == 'completion_rate':
-                    df[col] = 0.7
-                else:
-                    df[col] = 0.0
+                df[col] = 0.8 if col == 'popularity' else 0.7 if col == 'completion_rate' else 0.0
         
-        if 'level' in df.columns:
-            df['level'] = df['level'].apply(lambda x: 'Intermediate' if pd.isna(x) or x.strip() == "" else x)
-        else:
+        if 'level' not in df.columns:
             logger.warning(f"'level' column missing in {file_path}. Adding default 'Intermediate'.")
             df['level'] = 'Intermediate'
+        else:
+            df['level'] = df['level'].fillna('Intermediate')
         
         return df
-    except ValueError as ve:
-        logger.error(f"ValueError loading {file_path}: {ve}. Using fallback data.")
-        if fallback_data is not None:
-            logger.info(f"Using fallback data for {file_path}")
-            return pd.DataFrame(fallback_data)
-        return None
     except Exception as e:
         logger.error(f"Error loading {file_path}: {e}. Using fallback data.")
-        if fallback_data is not None:
-            logger.info(f"Using fallback data for {file_path}")
-            return pd.DataFrame(fallback_data)
-        return None
+        return pd.DataFrame(fallback_data) if fallback_data is not None else None
 
 # Load datasets with fallbacks
-questions_df = load_dataset("Generated_Skill-Based_Questions.csv", ["Skill", "Question", "Answer"], [], {
+questions_df = load_dataset("Generated_Skill-Based_Questions.csv", fallback_data={
     'Skill': ['Linux', 'Git', 'Node.js', 'Python', 'Kubernetes'],
     'Question': ['Advanced Linux question', 'Advanced Git question', 'Basic Node.js question', 
                  'Intermediate Python question', 'Basic Kubernetes question'],
@@ -127,28 +114,28 @@ def load_universal_model():
         if os.path.exists(UNIVERSAL_MODEL_PATH):
             logger.info(f"Loading universal model from {UNIVERSAL_MODEL_PATH}")
             return SentenceTransformer(UNIVERSAL_MODEL_PATH)
-        else:
-            logger.info(f"Loading universal model: {default_model}")
-            model = SentenceTransformer(default_model)
-            model.save(UNIVERSAL_MODEL_PATH)
-            return model
+        logger.info(f"Loading universal model: {default_model}")
+        model = SentenceTransformer(default_model)
+        model.save(UNIVERSAL_MODEL_PATH)
+        return model
     except Exception as e:
         logger.error(f"Failed to load universal model {default_model}: {e}. Exiting.")
         exit(1)
 
 universal_model = load_universal_model()
 
-if os.path.exists(DETECTOR_MODEL_PATH):
-    detector_tokenizer = AutoTokenizer.from_pretrained(DETECTOR_MODEL_PATH)
-    detector_model = AutoModelForSequenceClassification.from_pretrained(DETECTOR_MODEL_PATH)
-else:
-    detector_tokenizer = AutoTokenizer.from_pretrained("roberta-base-openai-detector")
-    detector_model = AutoModelForSequenceClassification.from_pretrained("roberta-base-openai-detector")
+try:
+    detector_tokenizer = AutoTokenizer.from_pretrained(DETECTOR_MODEL_PATH if os.path.exists(DETECTOR_MODEL_PATH) else "roberta-base-openai-detector")
+    detector_model = AutoModelForSequenceClassification.from_pretrained(DETECTOR_MODEL_PATH if os.path.exists(DETECTOR_MODEL_PATH) else "roberta-base-openai-detector")
+except Exception as e:
+    logger.error(f"Failed to load detector model: {e}. Exiting.")
+    exit(1)
 
 # Load Precomputed Resources
 def load_precomputed_resources():
     global tfidf_vectorizer, skill_tfidf, question_to_answer, faiss_index, answer_embeddings, course_similarity, job_similarity
-    if all(os.path.exists(p) for p in [TFIDF_PATH, SKILL_TFIDF_PATH, QUESTION_ANSWER_PATH, FAISS_INDEX_PATH, ANSWER_EMBEDDINGS_PATH, COURSE_SIMILARITY_PATH, JOB_SIMILARITY_PATH]):
+    paths = [TFIDF_PATH, SKILL_TFIDF_PATH, QUESTION_ANSWER_PATH, FAISS_INDEX_PATH, ANSWER_EMBEDDINGS_PATH, COURSE_SIMILARITY_PATH, JOB_SIMILARITY_PATH]
+    if all(os.path.exists(p) for p in paths):
         try:
             with open(TFIDF_PATH, 'rb') as f: tfidf_vectorizer = pickle.load(f)
             with open(SKILL_TFIDF_PATH, 'rb') as f: skill_tfidf = pickle.load(f)
@@ -180,6 +167,10 @@ def precompute_resources():
         faiss_index = faiss.IndexFlatL2(answer_embeddings.shape[1])
         faiss_index.add(answer_embeddings)
         
+        # Initialize course_similarity and job_similarity as empty dicts if not available
+        course_similarity = course_similarity or {}
+        job_similarity = job_similarity or {}
+        
         with open(TFIDF_PATH, 'wb') as f: pickle.dump(tfidf_vectorizer, f)
         with open(SKILL_TFIDF_PATH, 'wb') as f: pickle.dump(skill_tfidf, f)
         with open(QUESTION_ANSWER_PATH, 'wb') as f: pickle.dump(question_to_answer, f)
@@ -200,13 +191,13 @@ def evaluate_response(args):
         if not user_answer:
             return skill, 0.0, False
 
-        inputs = detector_tokenizer(user_answer, return_tensors="pt", truncation=True, max_length=512)
+        inputs = detector_tokenizer(user_answer, return_tensors="pt", truncation=True, max_length=512, padding=True)
         with torch.no_grad():
             logits = detector_model(**inputs).logits
         probs = scipy.special.softmax(logits, axis=1).tolist()[0]
         is_ai = probs[1] > 0.5
 
-        user_embedding = universal_model.encode([user_answer], batch_size=128, convert_to_tensor=True, device="cuda" if torch.cuda.is_available() else "cpu")[0]
+        user_embedding = universal_model.encode([user_answer], batch_size=1, convert_to_tensor=True, device="cuda" if torch.cuda.is_available() else "cpu")[0]
         expected_embedding = torch.tensor(answer_embeddings[question_idx])
         score = util.pytorch_cos_sim(user_embedding, expected_embedding).item() * 100
 
@@ -224,7 +215,8 @@ def evaluate_response(args):
 def get_questions_for_skills(skills):
     user_questions = []
     for skill in skills:
-        skill_questions = questions_df[questions_df['Skill'] == skill]
+        skill = skill.strip().capitalize()  # Standardize skill format
+        skill_questions = questions_df[questions_df['Skill'].str.capitalize() == skill]
         if not skill_questions.empty:
             user_questions.append(skill_questions.sample(1).iloc[0].to_dict())
         else:
@@ -246,7 +238,7 @@ def recommend_courses_from_mongo(skills_to_improve, user_level, upgrade=False):
             "skills": {"$in": skills_to_improve},
             "category": {"$regex": target_level, "$options": "i"}
         }
-        courses = courses_collection.find(query).limit(3)
+        courses = list(courses_collection.find(query).limit(3))
         return [{"title": course["title"], "provider": course.get("provider", "Unknown")} for course in courses]
     except Exception as e:
         logger.error(f"Course recommendation error: {e}")
@@ -262,7 +254,7 @@ def recommend_jobs_from_mongo(user_skills, user_level):
             "skills": {"$in": user_skills},
             "status": "active"
         }
-        jobs = jobs_collection.find(query).limit(5)
+        jobs = list(jobs_collection.find(query).limit(5))
         return [{"jobTitle": job["jobTitle"], "companyName": job["companyName"], "location": job.get("location", "Remote")} for job in jobs]
     except Exception as e:
         logger.error(f"Job recommendation error: {e}")
@@ -283,6 +275,9 @@ def get_questions():
             return jsonify({"error": "Missing skills field"}), 400
 
         user_skills = [s.strip() for s in data['skills'] if isinstance(s, str)]
+        if not user_skills:
+            return jsonify({"error": "No valid skills provided"}), 400
+
         load_precomputed_resources()
         questions = get_questions_for_skills(user_skills)
         return jsonify({"questions": questions})
@@ -302,7 +297,7 @@ def assess_skills():
         answers = [a.strip() for a in data['answers'] if isinstance(a, str)]
         user_level = data.get('user_level', 'Intermediate').strip()
 
-        if len(answers) != len(user_skills):
+        if not user_skills or len(answers) != len(user_skills):
             return jsonify({"error": "Answers count must match skills count"}), 400
 
         load_precomputed_resources()
@@ -315,8 +310,12 @@ def assess_skills():
             if not answer or answer.lower() == 'skip':
                 user_responses.append((row['Skill'], None, None))
             else:
-                question_idx = questions_df.index[questions_df['Question'] == row['Question']][0]
-                user_responses.append((row['Skill'], answer, question_idx))
+                question_idx = questions_df.index[questions_df['Question'] == row['Question']].tolist()
+                if not question_idx:
+                    logger.warning(f"Question not found in dataset: {row['Question']}")
+                    user_responses.append((row['Skill'], None, None))
+                    continue
+                user_responses.append((row['Skill'], answer, question_idx[0]))
 
         results = [evaluate_response(response) for response in user_responses]
 
@@ -331,18 +330,20 @@ def assess_skills():
             else:
                 user_scores[skill] = score
                 ai_flags[skill] = is_ai
-            scores_list.append(score)
+            if score > 0:
+                scores_list.append(score)
 
         # Update user profile with scores
         skill_scores = [{"skill": skill, "score": score} for skill, score, _ in results if score > 0]
         users_collection.update_one(
             {"_id": user_id},
-            {"$set": {"skillScores": skill_scores}}
+            {"$set": {"skillScores": skill_scores}},
+            upsert=True
         )
 
         mean_score = np.mean(scores_list) if scores_list else 50
         dynamic_threshold = max(40, mean_score)
-        weak_skills = [skill for skill, score in user_scores.items() if score < dynamic_threshold]
+        weak_skills = [skill for skill, score in user_scores.items() if score > 0 and score < dynamic_threshold]
 
         courses = recommend_courses_from_mongo(weak_skills or user_skills, user_level, upgrade=not weak_skills)
         jobs = recommend_jobs_from_mongo(user_skills, user_level)
@@ -353,12 +354,12 @@ def assess_skills():
                     {
                         "skill": skill,
                         "progress": f"{'■' * int(score//10)}{'-' * (10 - int(score//10))}",
-                        "score": f"{score:.2f} %",
+                        "score": f"{score:.2f}%",
                         "origin": "AI-Generated" if is_ai else "Human-Written"
                     } for skill, score, is_ai in results
                 ],
-                "mean_score": mean_score,
-                "dynamic_threshold": dynamic_threshold,
+                "mean_score": round(mean_score, 2),
+                "dynamic_threshold": round(dynamic_threshold, 2),
                 "weak_skills": weak_skills,
                 "skipped_questions": skipped_questions
             },
@@ -370,4 +371,4 @@ def assess_skills():
         return jsonify({"error": "Internal server error"}), 500
 
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, threaded=True)
+    app.run(host='0.0.0.0', port=7860)