Update app.py

app.py

@@ -49,11 +49,11 @@ def load_dataset(file_path, required_columns=[]):
         df = pd.read_csv(file_path)
         for col in required_columns:
             if col not in df.columns:
-                print(f"⚠ Warning: Column '{col}' missing in {file_path}. Using default values.")
+                logger.warning(f"Column '{col}' missing in {file_path}. Using default values.")
                 df[col] = "" if col != 'level' else 'Intermediate'
         return df
     except FileNotFoundError:
-        print(f"❌ Error: Dataset not found at {file_path}. Exiting.")
+        logger.error(f"Dataset not found at {file_path}. Exiting.")
         return None
 
 user_df = load_dataset("Updated_User_Profile_Dataset.csv", ["name", "skills", "level"])
@@ -72,6 +72,15 @@ if courses_df is None or 'skills' not in courses_df.columns or courses_df['skill
         'completion_rate': [0.7, 0.65, 0.8, 0.6]
     })
 
+# 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)
@@ -216,49 +225,79 @@ app = Flask(__name__)
 @app.route('/assess', methods=['POST'])
 def assess_skills():
     data = request.get_json()
+    logger.info(f"Received request: {data}")
+    
     if not data or 'user_index' not in data or 'answers' not in data:
+        logger.error("Invalid input: Missing 'user_index' or 'answers' in JSON body.")
         return jsonify({"error": "Invalid input. Provide 'user_index' and 'answers' in JSON body."}), 400
 
+    # Validate answers length immediately
+    answers = data['answers']
+    if not isinstance(answers, list):
+        logger.error(f"Answers must be a list, got: {type(answers)}")
+        return jsonify({"error": "Answers must be a list."}), 400
+    if len(answers) != 4:
+        logger.error(f"Expected exactly 4 answers, but received {len(answers)}.")
+        return jsonify({"error": f"Please provide exactly 4 answers. Received {len(answers)}."}), 400
+
     user_index = int(data['user_index'])
     if user_index < 0 or user_index >= len(user_df):
+        logger.error(f"Invalid user index: {user_index}. Must be between 0 and {len(user_df) - 1}.")
         return jsonify({"error": "Invalid user index."}), 400
 
     user_text = user_df.loc[user_index, 'skills']
     user_skills = [skill.strip() for skill in user_text.split(",") if skill.strip()] if isinstance(user_text, str) else ["Python", "SQL"]
     user_name = user_df.loc[user_index, 'name']
     user_level = user_df.loc[user_index, 'level'] if 'level' in user_df.columns and pd.notna(user_df.loc[user_index, 'level']) else 'Intermediate'
+    logger.info(f"User: {user_name}, Skills: {user_skills}, Level: {user_level}")
 
     initialize_resources(user_skills)
 
-    filtered_questions = questions_df[questions_df['Skill'].isin(user_skills)]
+    # Normalize skills for case-insensitive matching
+    filtered_questions = questions_df[questions_df['Skill'].str.lower().isin([skill.lower() for skill in user_skills])]
+    logger.info(f"Filtered questions shape: {filtered_questions.shape}")
+    logger.info(f"Available skills in questions_df: {filtered_questions['Skill'].unique().tolist()}")
     if filtered_questions.empty:
+        logger.error("No matching questions found for the user's skills.")
         return jsonify({"error": "No matching questions found!"}), 500
     
     user_questions = []
     for skill in user_skills:
-        skill_questions = filtered_questions[filtered_questions['Skill'] == skill]
+        skill_questions = filtered_questions[filtered_questions['Skill'].str.lower() == skill.lower()]
+        logger.info(f"Questions for skill '{skill}': {len(skill_questions)}")
         if not skill_questions.empty:
             user_questions.append(skill_questions.sample(1).iloc[0])
+        else:
+            logger.warning(f"No questions found for skill '{skill}'. Using a default question.")
+            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)
+    logger.info(f"Selected questions: {user_questions[['Skill', 'Question']].to_dict(orient='records')}")
 
     if len(user_questions) != 4:
-        return jsonify({"error": "Not enough questions for all skills!"}), 500
-
-    answers = data['answers']
-    if len(answers) != 4:
-        return jsonify({"error": "Please provide exactly 4 answers."}), 400
+        logger.error(f"Not enough questions for all skills. Expected 4, got {len(user_questions)}.")
+        return jsonify({"error": f"Not enough questions for all skills! Expected 4, got {len(user_questions)}."}), 500
 
     user_responses = []
     for idx, row in user_questions.iterrows():
         answer = answers[idx]
+        logger.debug(f"Pairing question for skill '{row['Skill']}' with answer at index {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']))
 
-    with Pool(cpu_count()) as pool:
-        eval_args = [(skill, user_code, question) for skill, user_code, question in user_responses if user_code]
-        results = pool.map(evaluate_response, eval_args)
+    try:
+        with Pool(cpu_count()) as pool:
+            eval_args = [(skill, user_code, question) for skill, user_code, question in user_responses if user_code]
+            logger.info(f"Evaluating {len(eval_args)} answers using multiprocessing pool.")
+            results = pool.map(evaluate_response, eval_args)
+    except Exception as e:
+        logger.error(f"Error in evaluate_response: {str(e)}", exc_info=True)
+        return jsonify({"error": "Failed to evaluate answers due to an internal error."}), 500
 
     user_scores = {}
     ai_flags = {}
@@ -301,6 +340,7 @@ def assess_skills():
         "recommended_courses": courses_output,
         "recommended_jobs": jobs_output
     }
+    logger.info(f"Response: {response}")
     return jsonify(response)
 
 if __name__ == '__main__':