feat: enhance career analysis functionality with detailed career path options and scoring metrics for user profiles

app/constants.py

@@ -13,3 +13,149 @@ ROLE_PLACEHOLDER = [
     "e.g. Site Reliability Engineer",
     "e.g. Infrastructure Engineer",
 ]
+
+SAMPLE_RESULT = """
+Based on the provided career profile, we can identify several potential career paths that align with the individual's experience, skills, and aspirations. 
+For each option, I’ll assess its performance in the short, medium, and long term for each criterion. I’ll assign rough scores (1-5, where 1 is low and 5 is high) based on your background and goals, then explain the reasoning.
+
+### Option 1: Pursue a PhD
+- **Short-term** (1-3 years):
+Financial Success: 2 (Stipends are modest, typically $20K-$40K/year, depending on location and funding.)
+Impact on Helping Others: 2 (Focus is on learning and early research, with limited immediate impact.)
+Winning Track Record: 3 (You’re building toward a prestigious degree, but no major achievements yet.)
+- **Medium-term** (3-10 years):
+Financial Success: 4 (Post-PhD, you could secure high-paying roles in industry or academia, e.g., $100K+ in tech.)
+Impact on Helping Others: 4 (Research in AI or data science could address significant problems.)
+Winning Track Record: 5 (A PhD is a globally recognized achievement, opening doors to elite roles.)
+- **Long-term** (10+ years):
+Financial Success: 4 (Potential for six-figure salaries in industry or stable academic positions.)
+Impact on Helping Others: 5 (Breakthrough research or leadership in impactful projects.)
+Winning Track Record: 5 (A PhD can lead to a career of notable contributions.)
+
+### Option 2: Continue in Data Science (Industry)
+- **Short-term**:
+Financial Success: 4 (With 2 years of experience, you can likely secure $80K-$120K roles.)
+Impact on Helping Others: 3 (Depends on projects—e.g., healthcare analytics could be impactful.)
+Winning Track Record: 4 (Successful projects or promotions enhance your resume.)
+- **Medium-term**:
+Financial Success: 4 (Senior roles could exceed $150K with experience.)
+Impact on Helping Others: 4 (Leading impactful initiatives becomes possible.)
+Winning Track Record: 4 (A string of achievements strengthens your profile.)
+- **Long-term**:
+Financial Success: 4 (Potential for executive or specialized roles with high pay.)
+Impact on Helping Others: 4 (Influence grows with seniority or project scope.)
+Winning Track Record: 4 (Consistent success signals expertise.)
+**Notes**: Your current path offers stability and growth, leveraging your existing skills and experience.
+
+### Option 3: Switch to Quantitative Finance or Software Engineering
+- **Short-term**:
+Financial Success: 5 (Entry-level roles in finance or tech often start at $100K+.)
+Impact on Helping Others: 3 (Varies—e.g., less direct in finance, more in software for social good.)
+Winning Track Record: 3 (You’d need to build new credentials, but your skills transfer well.)
+- **Medium-term**:
+Financial Success: 5 (High earning potential, e.g., $200K+ in quant finance.)
+Impact on Helping Others: 3 (Depends on the role—less predictable than data science.)
+Winning Track Record: 4 (Success in these fields is visible and respected.)
+- **Long-term**:
+Financial Success: 5 (Top earners in these fields can make millions.)
+Impact on Helping Others: 3 (Impact varies widely by role.)
+Winning Track Record: 4 (Strong achievements possible.)
+**Notes**: Switching requires some upskilling, but your math and programming background make it feasible.
+
+### Option 4: Entrepreneurship
+- **Short-term**:
+Financial Success: 1 (High risk—little to no income initially.)
+Impact on Helping Others: 4 (A venture solving real problems could have early impact.)
+Winning Track Record: 4 (Starting something is notable, even if small-scale.)
+- **Medium-term**:
+Financial Success: 3 (Success could yield moderate to high returns; failure is common.)
+Impact on Helping Others: 5 (A thriving business could scale solutions widely.)
+Winning Track Record: 5 (A successful startup is a major credential.)
+- **Long-term**:
+Financial Success: 5 (Potential for significant wealth if successful.)
+Impact on Helping Others: 5 (Large-scale impact possible.)
+Winning Track Record: 5 (Entrepreneurial success opens elite opportunities.)
+Notes: High risk, high reward—requires a strong idea and execution, but aligns with your AI and data science skills.
+
+### Option 5: Academia/Research Without a PhD
+- **Short-term**:
+Financial Success: 2 (Low-paying roles like research assistant, ~$30K-$50K.)
+Impact on Helping Others: 2 (Supportive roles with limited influence.)
+Winning Track Record: 2 (Few notable achievements possible.)
+- **Medium-term**:
+Financial Success: 2 (Pay remains modest without a PhD.)
+Impact on Helping Others: 3 (Contributions grow if you co-author or assist.)
+Winning Track Record: 3 (Some recognition possible, but limited.)
+- **Long-term**:
+Financial Success: 2 (Caps out below industry or PhD levels.)
+Impact on Helping Others: 3 (Niche impact possible.)
+Winning Track Record: 3 (Hard to advance significantly.)
+**Notes**: This path is constrained without a PhD, making it less competitive.
+
+### Option 6: Complete or Pursue a Master’s Degree
+- **Short-term**:
+Financial Success: 1 (Costly unless funded; no income during study.)
+Impact on Helping Others: 2 (Limited during the program.)
+Winning Track Record: 3 (A degree builds your profile.)
+- **Medium-term**:
+Financial Success: 4 (Better job prospects post-degree.)
+Impact on Helping Others: 3 (Depends on subsequent career.)
+Winning Track Record: 4 (A prestigious master’s is a strong signal.)
+- **Long-term**:
+Financial Success: 4 (Comparable to industry paths.)
+Impact on Helping Others: 4 (Depends on application.)
+Winning Track Record: 4 (Opens doors, but less than a PhD.)
+**Notes**: Your experience may already suffice for many jobs, but a funded program could be worth considering.
+
+### Next Step: Rank Options with Weighted Scores
+Since you’re willing to sacrifice short-term gains for long-term success, I’ll weigh long-term performance more heavily. Let’s calculate a total score for each option:
+
+Formula: Total Score = (Short-term Avg) + (Medium-term Avg) + 2 × (Long-term Avg)
+Averages are computed as (Financial + Impact + Track Record) ÷ 3.
+
+**PhD**
+- Short-term: (2+2+3)/3 = 2.33
+- Medium-term: (4+4+5)/3 = 4.33
+- Long-term: (4+5+5)/3 = 4.67
+- Total: 2.33 + 4.33 + 2 × 4.67 = 16
+
+**Data Science (Industry)**
+- Short-term: (4+3+4)/3 = 3.67
+- Medium-term: (4+4+4)/3 = 4
+- Long-term: (4+4+4)/3 = 4
+- Total: 3.67 + 4 + 2 × 4 = 15.67
+
+**Quant Finance/Software Engineering**
+- Short-term: (5+3+3)/3 = 3.67
+- Medium-term: (5+3+4)/3 = 4
+- Long-term: (5+3+4)/3 = 4
+- Total: 3.67 + 4 + 2 × 4 = 15.67
+
+**Entrepreneurship**
+- Short-term: (1+4+4)/3 = 3
+- Medium-term: (3+5+5)/3 = 4.33
+- Long-term: (5+5+5)/3 = 5
+- Total: 3 + 4.33 + 2 × 5 = 17.33
+
+**Academia Without PhD**
+- Short-term: (2+2+2)/3 = 2
+- Medium-term: (2+3+3)/3 = 2.67
+- Long-term: (2+3+3)/3 = 2.67
+- Total: 2 + 2.67 + 2 × 2.67 = 10.01
+
+**Master’s Degree**
+- Short-term: (1+2+3)/3 = 2
+- Medium-term: (4+3+4)/3 = 3.67
+- Long-term: (4+4+4)/3 = 4
+- Total: 2 + 3.67 + 2 × 4 = 13.67
+
+### Final Ranking
+
+### Final Ranking
+- **Entrepreneurship**: 17.33
+- **PhD**: 16
+- **Data Science (Industry)**: 15.67
+- **Quant Finance/Software Engineering**: 15.67
+- **Master’s Degree**: 13.67
+- **Academia Without PhD**: 10.01
+"""

app/main.py

@@ -21,36 +21,9 @@ analyzer = CareerAnalyzer(model_name="gpt-4o-mini")
 
 @monitor_api
 def analyze_career(
-    roles_data,
-    achievements,
-    education,
-    edu_achievements,
-    goals,
-    insights,
-    time_preference,
-    financial_weight,
-    impact_weight,
-    opportunity_weight,
+    *args,
 ):
-    # Normalize weights to ensure they sum to 1
-
-    # Prepare user data
-    user_data = {
-        "roles": roles_data,
-        "achievements": achievements,
-        "educations": education,
-        "edu_achievements": edu_achievements,
-        "goals": goals,
-        "insights": insights,
-        "time_preference": time_preference,
-        "financial_weight": financial_weight,
-        "impact_weight": impact_weight,
-        "opportunity_weight": opportunity_weight,
-    }
-
-    # Get analysis
-
-    result = analyzer.analyze(user_data)
+    result = analyzer.analyze(*args)
 
     return result
 
@@ -60,17 +33,20 @@ with gr.Blocks(theme="soft") as demo:
     # State for number of roles
     role_count = gr.State(1)  # Start with 1 role field
     education_count = gr.State(1)  # Start with 1 education field
+    professional_background_dict = gr.State({})  # State to store combined roles data
+    education_background_dict = gr.State({})  # State to store combined education data
     professional_background = gr.State("")  # State to store combined roles data
     professional_achievements = gr.State("")  # State to store combined roles data
     education_background = gr.State("")  # State to store combined education background
     education_achievements = gr.State("")  # State to store education achievements
     goals = gr.State("")  # State to store combined goals
     insights = gr.State("")  # State to store combined insights
-    time_preference = gr.State("")  # State to store time preference
+    time_preference = gr.State("Mid-term (10 years)")  # State to store time preference
     financial_weight = gr.State(2)  # State to store financial weight
     impact_weight = gr.State(2)  # State to store impact weight
     opportunity_weight = gr.State(2)  # State to store opportunity weight
     output = gr.State("")  # State to store output
+    raw_list_inputs = gr.State([])  # State to store raw list inputs
 
     gr.Markdown(
         """
@@ -83,7 +59,7 @@ with gr.Blocks(theme="soft") as demo:
 
     with gr.Row():
         submit_btn = gr.Button("Analyze Career Paths", variant="primary", size="lg")
-        clear_btn = gr.Button("Clear All", variant="stop", size="lg")
+        clear_btn = gr.Button("Clear", variant="stop", size="lg")
         example_btn = gr.Button("Load Example", variant="secondary", size="lg")
 
     with gr.Row():
@@ -117,20 +93,73 @@ with gr.Blocks(theme="soft") as demo:
                 @gr.render(inputs=role_count)
                 def render_roles(r_count):
                     for i in range(r_count):
+                        if i not in professional_background_dict.value:
+                            professional_background_dict.value[i] = {
+                                "role": "",
+                                "exp": "",
+                                "professional_achievement": "",
+                            }
                         with gr.Row():
+                            interactive = i == r_count - 1
                             role = gr.Textbox(
                                 key=f"role_{i}",
                                 label=f"Role {i + 1}"
                                 + (" (Current)" if i == 0 else ""),
                                 placeholder=ROLE_PLACEHOLDER[i % len(ROLE_PLACEHOLDER)],
                                 scale=3,
+                                interactive=interactive,
+                                inputs=professional_background_dict.value[i].get(
+                                    "role", ""
+                                ),
                             )
+
+                            def update_professional_background_dict(key, value, i):
+                                professional_background_dict.value[i][key] = value
+                                final_string = ""
+                                for i in professional_background_dict.value:
+                                    role = professional_background_dict.value[i].get(
+                                        "role"
+                                    )
+                                    exp = professional_background_dict.value[i].get(
+                                        "exp"
+                                    )
+                                    professional_achievement = (
+                                        professional_background_dict.value[i].get(
+                                            "professional_achievement"
+                                        )
+                                    )
+                                    final_string += f"{role} - {exp} years. Achieved: \n{professional_achievement}\n\n"
+
+                                return professional_background_dict.value, final_string
+
+                            role.input(
+                                lambda x: update_professional_background_dict(
+                                    "role", x, i
+                                ),
+                                inputs=[role],
+                                outputs=[
+                                    professional_background_dict,
+                                    professional_background,
+                                ],
+                            )
+
                             exp = gr.Number(
                                 key=f"exp_{i}",
                                 label="Years",
                                 value=1,
                                 minimum=0,
                                 scale=1,
+                                interactive=interactive,
+                            )
+                            exp.input(
+                                lambda x: update_professional_background_dict(
+                                    "exp", x, i
+                                ),
+                                inputs=[exp],
+                                outputs=[
+                                    professional_background_dict,
+                                    professional_background,
+                                ],
                             )
 
                         professional_achievement = gr.Textbox(
@@ -138,13 +167,23 @@ with gr.Blocks(theme="soft") as demo:
                             label="Notable Achievements",
                             lines=2,
                             placeholder="List key accomplishments, awards, or significant contributions.",
+                            interactive=interactive,
+                        )
+
+                        professional_achievement.input(
+                            lambda x: update_professional_background_dict(
+                                "professional_achievement", x, i
+                            ),
+                            inputs=[professional_achievement],
+                            outputs=[
+                                professional_background_dict,
+                                professional_background,
+                            ],
+                        )
+
+                        raw_list_inputs.value.extend(
+                            [role, exp, professional_achievement]
                         )
-                        if professional_achievement.value:
-                            professional_achievements.value += (
-                                professional_achievement.value
-                            )
-                        if professional_background.value:
-                            professional_background.value += f"{role} - {exp} years\n"
 
             with gr.Group():
                 gr.Markdown("### Educational Background")
@@ -179,6 +218,11 @@ with gr.Blocks(theme="soft") as demo:
                 @gr.render(inputs=education_count)
                 def render_education(e_count):
                     for i in range(e_count):
+                        if i not in education_background_dict.value:
+                            education_background_dict.value[i] = {
+                                "education": "",
+                                "education_achievement": "",
+                            }
                         with gr.Row():
                             education = gr.Textbox(
                                 key=f"education_{i}",
@@ -186,17 +230,57 @@ with gr.Blocks(theme="soft") as demo:
                                 lines=3,
                                 placeholder="e.g. Bachelor of Science in Computer Science, University of Technology",
                             )
+
+                            def update_educational_background_dict(key, value, i):
+                                education_background_dict.value[i][key] = value
+                                final_string = ""
+                                for i in education_background_dict.value:
+                                    education = education_background_dict.value[i].get(
+                                        "education"
+                                    )
+                                    edu_achievement = education_background_dict.value[
+                                        i
+                                    ].get("edu_achievement")
+                                    final_string += f"{education}. Achieved: \n{edu_achievement}\n\n"
+
+                                return education_background_dict.value, final_string
+
+                            education.input(
+                                lambda x: update_educational_background_dict(
+                                    "education", x, i
+                                ),
+                                inputs=[education],
+                                outputs=[
+                                    education_background_dict,
+                                    education_background,
+                                ],
+                            )
+
                             edu_achievement = gr.Textbox(
                                 key=f"edu_achievement_{i}",
                                 label="Academic Achievements",
                                 lines=3,
                                 placeholder="Awards, honors, notable projects or research during your education",
                             )
+
+                            edu_achievement.input(
+                                lambda x: update_educational_background_dict(
+                                    "education_achievement", x, i
+                                ),
+                                inputs=[education_achievements],
+                                outputs=[
+                                    education_background_dict,
+                                    education_background,
+                                ],
+                            )
+
                         if education.value:
                             education_background.value += education.value
                         if edu_achievement.value:
                             education_achievements.value += edu_achievement.value
 
+                        raw_list_inputs.value.extend([education, edu_achievement])
+
             with gr.Group():
                 gr.Markdown("### Future Plans")
                 goals = gr.Textbox(
@@ -260,7 +344,13 @@ with gr.Blocks(theme="soft") as demo:
                         )
 
         with gr.Column(scale=2):
-            output_box = gr.Textbox(label="Career Analysis Report", lines=25)
+            output_box = gr.Markdown(
+                output.value,
+                label="Career Analysis Report",
+                container=True,
+                height=614,
+                show_copy_button=False,
+            )
 
             with gr.Row():
                 copy_btn = gr.Button("📋 Copy to Clipboard", variant="secondary")
@@ -269,7 +359,7 @@ with gr.Blocks(theme="soft") as demo:
                 # Copy and share functionality
                 copy_btn.click(
                     copy_to_clipboard,
-                    inputs=output,
+                    inputs=output_box,
                 )
 
             # Add info section at the bottom
@@ -295,12 +385,10 @@ with gr.Blocks(theme="soft") as demo:
                 )
 
     submit_btn.click(
-        export_state,
+        lambda *args: analyze_career(*args) if export_state(*args) or True else None,
         inputs=[
             professional_background,
-            professional_achievements,
             education_background,
-            education_achievements,
             goals,
             insights,
             time_preference,
@@ -311,6 +399,17 @@ with gr.Blocks(theme="soft") as demo:
         outputs=[output_box],
     )
 
+    clear_btn.click(
+        fn=lambda: None, inputs=[], outputs=[], js="() => location.reload()"
+    )
+
+    """ 
+    example_btn.click(
+        fn=lambda _: SAMPLE_RESULT,
+        inputs=[output_box],
+        outputs=[output_box],
+    )
+     """
 
 # Launch the app
 if __name__ == "__main__":

app/utils.py

@@ -3,98 +3,21 @@ Utility functions for the LinkedIn Career Advice application.
 Handles input processing, clipboard operations, and sharing functionality.
 """
 
-import re
-import urllib.parse
-
 import pyperclip
 
 
-def combine_roles(count, *args):
-    roles_text = ""
-
-    for i in range(count):
-        # Calculate the index in args for this role's name and experience
-        name_idx = i
-        exp_idx = i + count // 2 + 1
-
-        if name_idx < len(args) and exp_idx < len(args):
-            role_name = args[name_idx]
-            experience = args[exp_idx]
-
-            if role_name and experience is not None:
-                roles_text += f"{role_name} ({experience} years)\n"
-
-    return roles_text.strip()
-
-
-def share_to_linkedin(text):
-    """Generate a LinkedIn sharing link"""
-    share_link = get_share_link(text)
-    return f"Share on LinkedIn: {share_link}"
-
-
-def combine_text_fields(text_list):
-    return "\n\n".join([text for text in text_list if text])
-
-
-def format_for_linkedin(text):
-    """Format analysis for LinkedIn sharing"""
-    # Extract just the summary/conclusion part to keep LinkedIn share concise
-    conclusion_match = re.search(
-        r"(?:Conclusion|Final Recommendation).*?:(.*?)(?=$)", text, re.DOTALL
-    )
-
-    if conclusion_match:
-        conclusion = conclusion_match.group(1).strip()
-        formatted = "I received this career path analysis insight:\n\n" + conclusion
-        return formatted[:500] + "..." if len(formatted) > 500 else formatted
-
-    # Fallback if no conclusion section found
-    shortened = text[:500] + "..." if len(text) > 500 else text
-    return "Career Path Analysis Results:\n\n" + shortened
-
-
-def get_share_link(text):
-    # Create a shortened version for sharing (LinkedIn has character limits)
-    summary = text[:500] + "..." if len(text) > 500 else text
-
-    # Get the LinkedIn sharing URL with the text encoded
-    base_url = "https://www.linkedin.com/sharing/share-offsite/"
-    params = {
-        "url": "https://huggingface.co/spaces/LinkedIn-Advice/career-path-advisor",
-        "title": "My Career Path Analysis",
-        "summary": summary,
-    }
-
-    share_url = f"{base_url}?{urllib.parse.urlencode(params)}"
-    return share_url
-
-
-def process_input_data(
-    role_count, roles_and_exps, achievements, educations, edu_achievements
-):
-    # Process roles and experience
-    roles_data = combine_roles(role_count, *roles_and_exps)
-
-    # Process achievements, education, and educational achievements
-    achievements_data = combine_text_fields(achievements)
-    education_data = combine_text_fields(educations)
-    edu_achievements_data = combine_text_fields(edu_achievements)
-
-    return roles_data, achievements_data, education_data, edu_achievements_data
-
-
 def copy_to_clipboard(text):
     """Copy text to clipboard"""
+    if not pyperclip.is_available():
+        print("Clipboard is not available on this system")
+        return None
     pyperclip.copy(text)
-    return "Report copied to clipboard!"
+    return None
 
 
 def export_state(
     professional_background,
-    professional_achievements,
     education_background,
-    education_achievements,
     goals,
     insights,
     time_preference,
@@ -104,9 +27,7 @@ def export_state(
 ) -> str:
     state_dict = {
         "Professional Background": professional_background,
-        "Professional Achievements": professional_achievements,
         "Education Background": education_background,
-        "Education Achievements": education_achievements,
         "Goals": goals,
         "Insights": insights,
         "Time Preference": time_preference,
@@ -116,6 +37,5 @@ def export_state(
     }
 
     formatted_output = "\n".join(f"{key}: {value}" for key, value in state_dict.items())
-    print(formatted_output)
 
     return formatted_output

linkedinadvice/career_analysis.py

@@ -17,7 +17,17 @@ class CareerAnalyzer:
         self.model_name = model_name
         self.temperature = temperature
 
-    def analyze(self, user_data):
+    def analyze(
+        self,
+        professional_background,
+        education_background,
+        goals,
+        insights,
+        time_preference,
+        financial_weight,
+        impact_weight,
+        opportunity_weight,
+    ):
         """
         Analyze career paths based on user data
 
@@ -30,74 +40,48 @@ class CareerAnalyzer:
             str: Formatted analysis results
         """
         # Use default equal weights if none provided
-        if scoring_weights is None:
-            scoring_weights = [
-                0.33,
-                0.33,
-                0.34,
-            ]  # Slightly more on opportunity to sum to 1.0
-
-        # Parse the roles data to extract current role and experience
-        roles_list = user_data.get("roles", "").split("\n")
-
-        # Identify current role (first one in the list)
-        current_role = ""
-        current_experience = 0
-        if roles_list and roles_list[0]:
-            parts = roles_list[0].split(" (")
-            if len(parts) == 2:
-                current_role = parts[0]
-                exp_part = parts[1].split(" years")[0]
-                try:
-                    current_experience = int(exp_part)
-                except ValueError:
-                    current_experience = 0
-
-        # Format previous roles (all except the first one)
-        prev_roles_str = ", ".join(roles_list[1:]) if len(roles_list) > 1 else ""
+        current_role = professional_background.split("\n\n")[0]
+        previous_roles = "\n\n".join(professional_background.split("\n\n")[1:])
+
 
         # Create the prompt with all available information
         prompt = f"""Analyze the following career profile and generate a taxonomy of potential career paths:
 
 Current Role: {current_role}
-Years in Current Role: {current_experience}
 """
 
         # Add previous roles if present
-        if prev_roles_str:
-            prompt += f"Previous Roles: {prev_roles_str}\n"
+        if previous_roles:
+            prompt += f"Previous Roles: {previous_roles}\n"
 
         # Add all the fields from user_data
-        prompt += f"""Professional Achievements: {user_data.get("achievements", "")}
-Educational Background: {user_data.get("educations", "")}
-Educational Achievements: {user_data.get("edu_achievements", "")}
-Career Goals: {user_data.get("goals", "")}
-Additional Insights: {user_data.get("insights", "")}
-
-Time Preference: {user_data.get("time_preference")}
-Financial Weight: {user_data.get("financial_weight", scoring_weights[0])}
-Impact Weight: {user_data.get("impact_weight", scoring_weights[1])}
-Opportunity Weight: {user_data.get("opportunity_weight", scoring_weights[2])}
+        prompt += f"""
+Educational Background: {education_background}
+Career Goals: {goals}
+Additional Insights: {insights}
 
-Generate 5 potential career paths that align with this profile. For each path, evaluate:
-1. Financial potential (scale 1-10) at 3, 10, and 10+ years
-2. Human impact potential (scale 1-10) at 3, 10, and 10+ years
-3. Opportunity creation potential (scale 1-10) at 3, 10, and 10+ years
+Time Preference: {time_preference}
+Financial Weight: {financial_weight}
+Impact Weight: {impact_weight}
+Opportunity Weight: {opportunity_weight}
 
-Show your reasoning for each score. 
+Help me as an expert career advisor. Provide a taxonomy to generate promising career paths on the timescale of {time_preference} and rate them them based on success on the short, medium and long term. For each path, evaluate:
+1. Financial potential (scale 1-3) at 3, 10, and 10+ years
+2. Human impact potential (scale 1-3) at 3, 10, and 10+ years
+3. Opportunity creation potential (scale 1-3) at 3, 10, and 10+ years
 
-Then calculate a weighted average based on the following weights:
-- Financial: {scoring_weights[0]}
-- Human Impact: {scoring_weights[1]}
-- Opportunity Creation: {scoring_weights[2]}
+Show your step by stepreasoning for each score. 
 
-And the time preference: {user_data.get("time_preference")}
+Then calculate an accurate weighted average based on the following weights:
+- Financial: {financial_weight}
+- Human Impact: {impact_weight}
+- Opportunity Creation: {opportunity_weight}
 
 Format the output clearly with sections for each career path, the scoring breakdown, and a final recommendation section ranking the paths from highest to lowest score.
 """
 
         # Add novel paths instruction if requested
-        if user_data.get("include_novel_options"):
+        if False:
             prompt += "\nPlease include at least one novel or unconventional career path in your analysis."
 
         # Print the prompt for debugging