Update app.py

app.py

@@ -22,10 +22,10 @@ logger = logging.getLogger(__name__)
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
 # Paths for saving artifacts
-MODEL_DIR = "./saved_models"
-FALLBACK_MODEL_DIR = "/tmp/saved_models"
+MODEL_DIR = "./saved_models"  # Primary location in /app/saved_models
+FALLBACK_MODEL_DIR = "/tmp/saved_models"  # Fallback if ./saved_models fails
 
-# Directory handling with improved error handling
+# Try to use the primary directory, fall back to /tmp if needed
 try:
     os.makedirs(MODEL_DIR, exist_ok=True)
     logger.info(f"Using model directory: {MODEL_DIR}")
@@ -44,7 +44,7 @@ QUESTION_ANSWER_PATH = os.path.join(chosen_model_dir, "question_to_answer.pkl")
 FAISS_INDEX_PATH = os.path.join(chosen_model_dir, "faiss_index.index")
 
 # Improved dataset loading with fallback
-def load_dataset(file_path, required_columns=[]):
+def load_dataset(file_path, required_columns=[], fallback_data=None):
     try:
         df = pd.read_csv(file_path)
         for col in required_columns:
@@ -54,17 +54,20 @@ def load_dataset(file_path, required_columns=[]):
         return df
     except Exception as e:
         logger.error(f"Error loading {file_path}: {e}")
+        if fallback_data is not None:
+            logger.info(f"Using fallback data for {file_path}")
+            return pd.DataFrame(fallback_data)
         return None
 
 # Load datasets with fallbacks
-questions_df = load_dataset("Generated_Skill-Based_Questions.csv", ["Skill", "Question", "Answer"]) or pd.DataFrame({
+questions_df = load_dataset("Generated_Skill-Based_Questions.csv", ["Skill", "Question", "Answer"], {
     'Skill': ['Linux', 'Git', 'Node.js', 'Python', 'Kubernetes'],
     'Question': ['Advanced Linux question', 'Advanced Git question', 'Basic Node.js question', 
                  'Intermediate Python question', 'Basic Kubernetes question'],
     'Answer': ['Linux answer', 'Git answer', 'Node.js answer', 'Python answer', 'Kubernetes answer']
 })
 
-courses_df = load_dataset("coursera_course_dataset_v2_no_null.csv", ["skills", "course_title", "Organization", "level"]) or pd.DataFrame({
+courses_df = load_dataset("coursera_course_dataset_v2_no_null.csv", ["skills", "course_title", "Organization", "level"], {
     'skills': ['Docker', 'Jenkins', 'Azure', 'Cybersecurity'],
     'course_title': ['Docker Mastery', 'Jenkins CI/CD', 'Azure Fundamentals', 'Cybersecurity Basics'],
     'Organization': ['Udemy', 'Coursera', 'Microsoft', 'edX'],
@@ -73,7 +76,7 @@ courses_df = load_dataset("coursera_course_dataset_v2_no_null.csv", ["skills", "
     'completion_rate': [0.7, 0.65, 0.8, 0.6]
 })
 
-jobs_df = load_dataset("Updated_Job_Posting_Dataset.csv", ["job_title", "company_name", "location", "required_skills", "job_description"]) or pd.DataFrame({
+jobs_df = load_dataset("Updated_Job_Posting_Dataset.csv", ["job_title", "company_name", "location", "required_skills", "job_description"], {
     'job_title': ['DevOps Engineer', 'Cloud Architect'],
     'company_name': ['Tech Corp', 'Cloud Inc'],
     'location': ['Remote', 'Silicon Valley'],
@@ -81,19 +84,32 @@ jobs_df = load_dataset("Updated_Job_Posting_Dataset.csv", ["job_title", "company
     'job_description': ['DevOps role description', 'Cloud architecture position']
 })
 
-# Model loading with validation
-def load_model(model_class, path, default_name):
-    try:
-        return model_class.from_pretrained(path)
-    except Exception as e:
-        logger.warning(f"Failed to load model from {path}: {e}. Using default {default_name}.")
-        return model_class.from_pretrained(default_name)
-
-universal_model = SentenceTransformer(UNIVERSAL_MODEL_PATH) if os.path.exists(UNIVERSAL_MODEL_PATH) else SentenceTransformer("all-MiniLM-L6-v2")
-detector_model = load_model(AutoModelForSequenceClassification, DETECTOR_MODEL_PATH, "roberta-base-openai-detector")
-detector_tokenizer = AutoTokenizer.from_pretrained(DETECTOR_MODEL_PATH) if os.path.exists(DETECTOR_MODEL_PATH) else AutoTokenizer.from_pretrained("roberta-base-openai-detector")
+# Validate questions_df
+if questions_df is None or questions_df.empty:
+    logger.error("questions_df is empty or could not be loaded. Exiting.")
+    exit(1)
+if not all(col in questions_df.columns for col in ["Skill", "Question", "Answer"]):
+    logger.error("questions_df is missing required columns. Exiting.")
+    exit(1)
+logger.info(f"questions_df loaded with {len(questions_df)} rows. Skills available: {questions_df['Skill'].unique().tolist()}")
+
+# Load or Initialize Models
+if os.path.exists(UNIVERSAL_MODEL_PATH):
+    universal_model = SentenceTransformer(UNIVERSAL_MODEL_PATH)
+else:
+    universal_model = SentenceTransformer("all-MiniLM-L6-v2")
+
+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")
+
+# Precompute Resources with Validation
+def resources_valid(saved_skills, current_skills):
+    return set(saved_skills) == set(current_skills)
 
-# Enhanced resource initialization
 def initialize_resources(user_skills):
     global tfidf_vectorizer, skill_tfidf, question_to_answer, faiss_index, answer_embeddings
     
@@ -247,37 +263,76 @@ def assess_skills():
         initialize_resources(user_skills)
 
         # Get relevant questions
-        user_questions = questions_df[questions_df['Skill'].str.lower().isin([s.lower() for s in user_skills])]
-        if user_questions.empty:
-            user_questions = questions_df.sample(len(user_skills))
-        
-        user_questions = user_questions.sample(len(user_skills)).reset_index(drop=True)
-        responses = list(zip(user_questions['Skill'], answers, user_questions['Question']))
+        filtered_questions = questions_df[questions_df['Skill'].str.lower().isin([skill.lower() for skill in user_skills])]
+        if filtered_questions.empty:
+            return jsonify({"error": "No matching questions found for the user's skills."}), 500
+
+        user_questions = []
+        for skill in user_skills:
+            skill_questions = filtered_questions[filtered_questions['Skill'].str.lower() == skill.lower()]
+            if not skill_questions.empty:
+                user_questions.append(skill_questions.sample(1).iloc[0])
+            else:
+                user_questions.append({
+                    'Skill': skill,
+                    'Question': f"What are the best practices for using {skill} in a production environment?",
+                    'Answer': f"Best practices for {skill} include proper documentation, monitoring, and security measures."
+                })
+        user_questions = pd.DataFrame(user_questions).reset_index(drop=True)
+
+        if len(user_questions) != len(user_skills):
+            return jsonify({"error": f"Internal error: Number of selected questions ({len(user_questions)}) does not match number of skills ({len(user_skills)})."}), 500
+
+        user_responses = []
+        for idx, row in user_questions.iterrows():
+            answer = answers[idx]
+            if not answer or answer.lower() == 'skip':
+                user_responses.append((row['Skill'], None, row['Question']))
+            else:
+                user_responses.append((row['Skill'], answer, row['Question']))
 
-        # Parallel processing with error handling
         with Pool(processes=min(cpu_count(), 4)) as pool:
-            results = pool.map(evaluate_response, responses)
+            eval_args = [(skill, user_code, question) for skill, user_code, question in user_responses if user_code]
+            results = pool.map(evaluate_response, eval_args)
 
-        # Process results
-        assessment = []
-        scores = []
+        user_scores = {}
+        ai_flags = {}
+        scores_list = []
+        skipped_questions = [f"{skill} ({question})" for skill, user_code, question in user_responses if user_code is None]
         for skill, score, is_ai in results:
-            assessment.append(f"{skill}: {score}% ({'AI' if is_ai else 'Human'})")
-            scores.append(score)
-        
-        mean_score = np.mean(scores) if scores else 0
-        weak_skills = [skill for skill, score, _ in results if score < max(60, mean_score)]
+            if skill in user_scores:
+                user_scores[skill] = max(user_scores[skill], score)
+                ai_flags[skill] = ai_flags[skill] or is_ai
+            else:
+                user_scores[skill] = score
+                ai_flags[skill] = is_ai
+            scores_list.append(score)
+
+        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]
 
         # Generate recommendations
         courses = recommend_courses(weak_skills or user_skills, user_level, upgrade=not weak_skills)
         jobs = recommend_jobs(user_skills, user_level)
 
         return jsonify({
-            "assessment": assessment,
-            "mean_score": round(mean_score, 1),
-            "weak_skills": weak_skills,
-            "courses": courses[:3],  # Top 3 courses
-            "jobs": jobs[:5]        # Top 5 jobs
+            "assessment_results": {
+                "skills": [
+                    {
+                        "skill": skill,
+                        "progress": f"{'■' * int(score//10)}{'-' * (10 - int(score//10))}",
+                        "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,
+                "weak_skills": weak_skills,
+                "skipped_questions": skipped_questions
+            },
+            "recommended_courses": courses[:3],
+            "recommended_jobs": jobs[:5]
         })
     except Exception as e:
         logger.error(f"Assessment error: {e}")