Upload app_fully_safe.py

app_fully_safe.py

@@ -0,0 +1,378 @@
+import gradio as gr
+import datetime
+import random
+from collections import defaultdict
+
+from utils.constants import TASK_DIFFICULTIES
+from utils.data_helpers import smart_label_converter, clean_text, extract_actions_from_feedback
+from utils.api_clients import initialize_api_clients
+from utils.embedding_model import initialize_embedding_model
+from utils.summarizer import initialize_summarizer
+from utils.constants import course_suggestions
+from modules.rag import load_docs, memo_rag_engine, batch_ingest_from_classcentral
+from modules.task_management import display_tasks, add_reward, calculate_progress, claim_reward, add_task, add_course_to_memo, mark_step_completed, calculate_visual_progress, reset_weekly_data
+from modules.analysis import analyze_linkedin, analyze_github, analyze_scraped_linkedin_profile, analyze_apify_dataset_ui
+from modules.analysis import fetch_and_analyze_linkedin
+import textwrap
+
+
+# ==== Global Variables ====
+completed_tasks = set()
+memo_data = []
+visual_steps = []
+
+# ==== API Clients & Models ====
+pc, pine_index, APIFY_TOKEN, OPENAI_API_KEY, TAVILY_API_KEY, client = initialize_api_clients()
+embedding_model = initialize_embedding_model()
+summarizer = initialize_summarizer()
+
+# ==== Gradio UI Components ====
+class RoadmapUnlockManager:
+    def __init__(self):
+        self.unlocked = False
+
+    def unlock_roadmap(self):
+        self.unlocked = True
+        return gr.update(visible=True)
+
+    def get_roadmap_visibility(self):
+        return gr.update(visible=self.unlocked)
+
+
+roadmap_unlock = RoadmapUnlockManager()
+
+
+# === Roadmap Renderer ===
+def render_text_roadmap(goal, steps):
+    global visual_steps
+    visual_steps = steps  # ✅ Ensure this is set fresh each time
+    while len(steps) < 6:
+        steps.append("...")
+    def mark_done(text): return f"~~{text}~~" if text in completed_tasks else text
+    roadmap = [
+        f"                       🏁 GOAL: {goal}",
+        "                      /\\",
+        "                     /  \\",
+        f"                    /    \\      • {mark_done(steps[5])}",
+        "                   /      \\",
+        f"                  /        \\     • {mark_done(steps[4])}",
+        "                 /          \\",
+        f"                /            \\         • {mark_done(steps[3])}",
+        "               /              \\",
+        f"              /                \\           • {mark_done(steps[2])}",
+        "             /                  \\",
+        f"            /                    \\                • {mark_done(steps[1])}",
+        "           /                      \\",
+        f"          /                        \\                    • {mark_done(steps[0])}",
+        "         /                          \\",
+        "        /                            \\",
+        " ____/                                \\____"]
+    return "\\n".join(roadmap)
+
+
+
+def recall_from_memory(user_id, goal):
+    try:
+        query = user_id + ":" + goal.replace(" ", "_")
+        result = pine_index.fetch([query])  # ✅ returns a FetchResponse object
+        
+        if query not in result.vectors:
+            return "❌ No saved plan found for this goal."
+
+        metadata = result.vectors[query].get("metadata", {})
+        steps = metadata.get("steps", [])
+        steps = [smart_label_converter(s) for s in steps if isinstance(s, str) and len(s.strip()) > 1]
+        summary = metadata.get("summary", "")
+        courses = metadata.get("courses", [])
+        course_section = ""
+
+        diagram = render_text_roadmap(goal, steps)
+        
+        if courses:
+            course_section = "\n\n### 📚 Recommended Courses\n" + "\n".join([f"- [{c['name']}]({c['url']})" for c in courses if 'name' in c and 'url' in c])
+
+        return f"""### 🔁 Recalled Plan for {goal}
+
+import textwrap
+
+def generate_smart_plan(user_id, start_date_str, goal):
+    import datetime
+    import difflib
+    import re
+
+    start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d").date()
+
+    if not user_id:
+        return "❌ Please enter a nickname in the Welcome tab.", "", "📅 Week 1"
+
+    user_key = user_id.strip().lower()
+    goal_key = goal.lower().strip()
+
+    if goal_key not in course_suggestions:
+        close_matches = difflib.get_close_matches(goal_key, course_suggestions.keys(), n=1, cutoff=0.6)
+        if close_matches:
+            goal_key = close_matches[0]
+
+    plan_markdown = f"""### Plan for {goal}
+
+{diagram}
+
+{summary}{course_section}
+
+_Source: See planner source_"""
+    
+    plan_source = "Loaded from memory"
+    save_to_memory(user_id, goal, summary, steps, courses)
+
+    # 2️⃣ Try Tavilly fallback
+    if not steps:
+        try:
+            print("🧪 Trying Tavilly fallback for:", goal_key)
+            result = call_tavilly_rag(user_id, goal_key)
+            print("✅ Tavilly returned something:", result)
+            tav_plan = re.sub(r'(Create a weekly roadmap.*?)\1+', r'\1', result[0], flags=re.DOTALL)
+            tav_steps = [smart_label_converter(s) for s in result[2] if isinstance(s, str) and len(s.strip()) > 1]
+            if tav_steps:
+                steps = tav_steps
+                diagram = render_text_roadmap(goal, steps)
+                summary = summarizer(f"Create a weekly roadmap for {goal}.", max_new_tokens=300, do_sample=False)[0]["generated_text"]
+                courses = get_courses_for_goal(goal_key)
+                course_section = "\n\n### 📚 Recommended Courses\n" + "\n".join([f"- [{name}]({url})" for name, url in courses]) if courses else ""
+                plan_markdown = f"""### Plan for {goal}
+
+{diagram}
+
+{summary}{course_section}
+
+_Source: See planner source_"""
+        plan_source = "Loaded from memory"
+
+    for step in steps:
+        if isinstance(step, str) and len(step.strip()) > 1:
+            add_task(user_id, task=step, duration=2, difficulty="Moderate", tag=None, source="career")
+
+    print("✅ Returning", len(steps), "steps for goal:", goal)
+    return plan_markdown, gr.update(choices=steps, value=[]), "📅 Week 1"
+
+
+
+with gr.Blocks(theme="NoCrypt/[email protected]",css="theme.css") as app:
+    user_id_state = gr.State()
+    roadmap_unlock = RoadmapUnlockManager()
+    start_date = gr.Textbox(label="📅 Start Date", value=str(datetime.date.today()))
+
+    with gr.Tabs():
+        with gr.Tab("✨ Welcome"):
+            with gr.Row(equal_height=True):
+                # LEFT: Intro
+                with gr.Column(scale=2):
+                    gr.Markdown("""
+                    # 👋 Welcome to Career Buddy!
+                     **Your AI-powered career planner** for LinkedIn, GitHub, and goal-tracking.**
+                    If you enjoy this project and want to help me beat OpenAI costs; support me below
+                    """)
+
+                    gr.HTML('''<a href="https://ko-fi.com/wishingonstars" target="_blank"><img src="https://unfetteredpatterns.blog/wp-content/uploads/2025/05/support_me_on_kofi_badge_dark.webp" style="height: 72px; padding: 4px;" alt="Support me on Ko-fi" /></a>''')
+
+                    gr.Markdown("""
+                    ### 🚀 Get Started
+                    1. **Enter your nickname** to personalize your journey.
+                    2. **Set your weekly goal** to stay on track.
+                    3. **Explore the tabs** for LinkedIn/GitHub analysis, smart planning, and more!
+                    """)
+
+                # RIGHT: User Input
+                with gr.Column(scale=1, elem_id="user-card"):
+                    gr.Markdown("## Your Journey Starts Here")
+                    nickname_input = gr.Textbox(label="Enter your Nickname", placeholder="e.g., DataScientistPro", interactive=True)
+                    weekly_goal_input = gr.Textbox(label="What's your weekly career goal?", placeholder="e.g., Apply to 5 jobs, finish a Python course", interactive=True)
+                    with gr.Row():
+                        save_btn = gr.Button("Save Profile")
+                        load_btn = gr.Button("Load Profile")
+
+                    gr.Markdown("### Your Progress")
+                    progress_output = gr.Markdown("", elem_id="progress-output")
+                    
+                    save_btn.click(fn=lambda nickname, goal: (save_user_profile(nickname, goal), nickname.strip().lower().replace(' ', '_')),inputs=[nickname_input, weekly_goal_input],outputs=[progress_output, user_id_state])
+
+                    load_btn.click(
+                        fn=lambda: load_user_profile(),
+                        inputs=[],
+                        outputs=[nickname_input, weekly_goal_input, progress_output, user_id_state]
+                    )
+
+        with gr.Tab("🔗 Linky (LinkedIn Analyzer)", elem_id="linky-tab"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    linkedin_url_input = gr.Textbox(label="LinkedIn Profile URL", placeholder="Paste your LinkedIn profile URL here", interactive=True)
+                    analyze_linkedin_btn = gr.Button("Analyze LinkedIn Profile")
+                    gr.Markdown("### Or analyze a local Apify dataset CSV")
+                    apify_dataset_btn = gr.Button("Analyze Apify Dataset (CSV)")
+                with gr.Column(scale=2):
+                    linkedin_analysis_output = gr.Markdown("", label="LinkedIn Analysis Results")
+
+            analyze_linkedin_btn.click(
+                fn=fetch_and_analyze_linkedin,
+                inputs=[linkedin_url_input],
+                outputs=linkedin_analysis_output
+            )
+            apify_dataset_btn.click(
+                fn=analyze_apify_dataset_ui,
+                inputs=[],
+                outputs=linkedin_analysis_output
+            )
+
+        with gr.Tab("🐙 GitGuru (GitHub Reviewer)", elem_id="gitguru-tab"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    github_readme_input = gr.Textbox(label="GitHub README Content", placeholder="Paste your main GitHub README content here", lines=10, interactive=True)
+                    analyze_github_btn = gr.Button("Analyze GitHub README")
+                with gr.Column(scale=2):
+                    github_analysis_output = gr.Markdown("", label="GitHub Analysis Results")
+
+            analyze_github_btn.click(
+                fn=analyze_github,
+                inputs=[github_readme_input],
+                outputs=github_analysis_output
+            )
+
+        with gr.Tab("🧠 Smart Planner", elem_id="planner-card"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    planner_goal_input = gr.Textbox(label="Your Goal", placeholder="e.g., Become a Data Scientist", interactive=True)
+                    planner_difficulty_input = gr.Dropdown(label="Difficulty", choices=TASK_DIFFICULTIES, value="Moderate", interactive=True)
+                    planner_generate_btn = gr.Button("Generate Roadmap")
+                with gr.Column(scale=2):
+                    roadmap_output = gr.Markdown("", label="Career Roadmap")
+                    planner_step_dropdown = gr.Dropdown(label="Planned Steps", choices=[], multiselect=True, visible=False)
+                    planner_week_marker = gr.Textbox(label="Current Week", value="📅 Week 1", visible=False)
+
+
+            planner_generate_btn.click(
+                fn=generate_smart_plan,
+                inputs=[user_id_state, start_date, planner_goal_input],
+                outputs=[roadmap_output, planner_step_dropdown, planner_week_marker])
+
+
+        with gr.Tab("🎯 Task Tracker", elem_id="gitguru-tab"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    task_name_input = gr.Textbox(label="Task Name", placeholder="e.g., Complete Python course", interactive=True)
+                    task_type_input = gr.Dropdown(label="Task Type", choices=["Learning", "Networking", "Project", "Application"], value="Learning", interactive=True)
+                    task_add_btn = gr.Button("Add Task")
+
+                    gr.Markdown("### Mark Task Steps Completed")
+                    task_step_input = gr.Textbox(label="Step to Mark Completed", placeholder="e.g., Chapter 1 of Python course", interactive=True)
+                    task_mark_completed_btn = gr.Button("Mark Step Completed")
+
+                    gr.Markdown("### Rewards")
+                    reward_amount_input = gr.Number(label="Reward Amount", value=10, interactive=True)
+                    reward_claim_btn = gr.Button("Claim Reward")
+
+                    reset_weekly_btn = gr.Button("Reset Weekly Data")
+
+                with gr.Column(scale=2):
+                    tasks_display = gr.Markdown("", label="Your Tasks")
+                    progress_bar = gr.HTML("", label="Weekly Progress")
+                    rewards_display = gr.Markdown("", label="Your Rewards")
+
+            task_add_btn.click(
+                fn=lambda user_id, task_name, task_type: add_task(user_id, task_name, task_type),
+                outputs=[tasks_display, progress_bar, rewards_display]
+
+            )
+
+            task_mark_completed_btn.click(
+                fn=lambda user_id, step: mark_step_completed(user_id, step, tasks_display, progress_bar, rewards_display),
+                inputs=[user_id_state, task_step_input],
+                outputs=[tasks_display, progress_bar, rewards_display]
+            )
+
+            reward_claim_btn.click(
+                fn=lambda user_id, amount: claim_reward(user_id, amount, rewards_display),
+                inputs=[user_id_state, reward_amount_input],
+                outputs=rewards_display
+            )
+
+            reset_weekly_btn.click(
+                fn=lambda user_id: reset_weekly_data(user_id, tasks_display, progress_bar, rewards_display),
+                inputs=[user_id_state],
+                outputs=[tasks_display, progress_bar, rewards_display]
+            )
+
+        with gr.Tab("📚 Memo (Course Recommender)", elem_id="gitguru-tab"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    memo_query_input = gr.Textbox(label="Ask about a course or topic", placeholder="e.g., Best Python courses for data science", interactive=True)
+                    memo_search_btn = gr.Button("Search Courses")
+                    gr.Markdown("### Add Course to Memo")
+                    memo_course_name_input = gr.Textbox(label="Course Name", interactive=True)
+                    memo_course_url_input = gr.Textbox(label="Course URL", interactive=True)
+                    memo_add_course_btn = gr.Button("Add Course")
+                with gr.Column(scale=2):
+                    memo_output = gr.Markdown("", label="Course Recommendations")
+
+            memo_search_btn.click(
+                fn=lambda query: memo_rag_engine(query, pine_index, embedding_model, client, summarizer),
+                inputs=[memo_query_input],
+                outputs=memo_output
+            )
+            memo_add_course_btn.click(
+                fn=lambda name, url: add_course_to_memo(name, url, pine_index, embedding_model, client, summarizer),
+                inputs=[memo_course_name_input, memo_course_url_input],
+                outputs=memo_output
+            )
+
+        with gr.Tab("📊 Visualizer", elem_id="gitguru-tab"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    visualizer_goal_input = gr.Textbox(label="Your Goal", placeholder="e.g., Become a Data Scientist", interactive=True)
+                    visualizer_generate_btn = gr.Button("Generate Visual Roadmap")
+                with gr.Column(scale=2):
+                    visualizer_output = gr.Plot(label="Visual Roadmap")
+
+            visualizer_generate_btn.click(
+                fn=lambda goal: generate_visual_roadmap(goal, visual_steps),
+                inputs=[visualizer_goal_input],
+                outputs=visualizer_output
+            )
+
+
+    def save_user_profile(nickname, weekly_goal):
+        user_id = nickname.lower().replace(" ", "_")
+        user_id_state.value = user_id
+        # In a real app, you\\'d save this to a database
+        return f"Profile for **{nickname}** saved! Weekly goal: **{weekly_goal}**"
+
+    def load_user_profile():
+        # In a real app, you\\'d load this from a database
+        # For now, just return some dummy data
+        return "DataScientistPro", "Apply to 5 jobs, finish a Python course", "Loaded dummy profile."
+
+    def generate_roadmap(goal, difficulty, pc, pine_index, client):
+        # This function would use the RAG system to generate a roadmap
+        # For now, return a placeholder
+        steps = [
+            "Learn Python Basics",
+            "Understand Data Structures & Algorithms",
+            "Master SQL",
+            "Explore Machine Learning Fundamentals",
+            "Build a Portfolio Project",
+            "Apply for Jobs"
+        ]
+        return render_text_roadmap(goal, steps)
+
+    def generate_visual_roadmap(goal, steps):
+        # This function would generate a visual roadmap using matplotlib or similar
+        # For now, return a placeholder plot
+        import matplotlib.pyplot as plt
+        fig, ax = plt.subplots()
+        ax.barh(steps, [1]*len(steps))
+        ax.set_title(f"Visual Roadmap for {goal}")
+        return fig
+
+
+app.launch(debug=True)
+
+
+"""