Create app.py

app.py

@@ -0,0 +1,440 @@
+import pandas as pd
+import datasets
+from sentence_transformers import SentenceTransformer, util
+import torch
+import re
+import nltk
+from nltk.corpus import words, stopwords
+import urllib.parse as _url
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+from nltk.stem import PorterStemmer
+import gradio as gr
+import spacy # --- NEW: Import spaCy ---
+
+# --- CORRECTED: Download necessary NLTK data ---
+# This revised block is more direct and ensures all packages are downloaded.
+for package in ['words', 'stopwords', 'averaged_perceptron_tagger', 'punkt']:
+    try:
+        nltk.data.find(f'corpora/{package}' if package in ['words', 'stopwords'] else f'taggers/{package}' if package == 'averaged_perceptron_tagger' else f'tokenizers/{package}')
+    except LookupError:
+        nltk.download(package)
+# ------------------------------------------------
+
+STOPWORDS = set(stopwords.words('english'))
+stemmer = PorterStemmer()
+
+# --- GLOBAL STATE & DATA ---
+original_df = None
+combined_df = None
+model = None
+combined_job_embeddings = None
+original_job_title_embeddings = None
+LLM_PIPELINE = None
+NLP_MODEL = None # --- NEW: Global variable for the spaCy model ---
+LLM_MODEL_NAME = "microsoft/phi-2"
+FINETUNED_MODEL_ID = "its-zion-18/projfinetuned"
+KNOWN_WORDS = set()
+
+# --- CORE NLP & HELPER FUNCTIONS ---
+def _norm_skill_token(s: str) -> str:
+    s = s.lower().strip()
+    s = re.sub(r'[\(\)\[\]\{\}\*]', '', s)
+    s = re.sub(r'^\W+|\W+$', '', s)
+    s = re.sub(r'\s+', ' ', s)
+    return s
+
+def _skill_match(token1: str, token2: str, threshold: float = 0.9) -> bool:
+    t1 = _norm_skill_token(token1)
+    t2 = _norm_skill_token(token2)
+    if t1 == t2 or t1 in t2 or t2 in t1:
+        return True
+    try:
+        if len(t1) > 2 and len(t2) > 2:
+            vectorizer = TfidfVectorizer().fit([t1, t2])
+            vectors = vectorizer.transform([t1, t2])
+            similarity = cosine_similarity(vectors)[0, 1]
+            if similarity >= threshold:
+                return True
+    except:
+        pass
+    return False
+
+def build_known_vocabulary(df: pd.DataFrame):
+    global KNOWN_WORDS
+    english_words = set(w.lower() for w in words.words())
+    job_words = set(re.findall(r'\b\w+\b', " ".join(df['full_text'].astype(str).tolist()).lower()))
+    job_words = {w for w in job_words if w.isalpha() and len(w) > 2}
+    KNOWN_WORDS = english_words | job_words
+    return "Known vocabulary built."
+
+def check_spelling_in_query(query: str) -> list[str]:
+    words_in_query = query.lower().split()
+    unrecognized_words = []
+    if not KNOWN_WORDS: return []
+    for word in words_in_query:
+        if word.isalpha() and len(word) > 1 and word not in KNOWN_WORDS:
+            unrecognized_words.append(word)
+    return list(set(unrecognized_words))
+
+def initialize_llm_client():
+    global LLM_PIPELINE
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL_NAME, trust_remote_code=True)
+        model_llm = AutoModelForCausalLM.from_pretrained(
+            LLM_MODEL_NAME, torch_dtype="auto", device_map="auto", trust_remote_code=True
+        )
+        LLM_PIPELINE = pipeline(
+            "text-generation", model=model_llm, tokenizer=tokenizer, max_new_tokens=100, do_sample=True, temperature=0.7
+        )
+        return True
+    except Exception as e:
+        print(f"🚨 ERROR initializing local LLM: {e}")
+        return False
+
+def llm_expand_query(user_input: str) -> str:
+    global LLM_PIPELINE
+    if not LLM_PIPELINE: return user_input
+    prompt_template = (
+        f"User's career interest: '{user_input}'\n"
+        f"Instruction: Based on the user's interest, write a concise, single-sentence summary (40-60 words) that elaborates on the core intent, typical skills, and responsibilities. "
+        f"Do not include a preamble, the user input, or any list formatting in the output. Just the expanded sentence.\n"
+        f"Expanded Intent:"
+    )
+    try:
+        response = LLM_PIPELINE(prompt_template, max_new_tokens=100, do_sample=True, temperature=0.6)
+        expanded_query = response[0]['generated_text'].strip().split("Expanded Intent:")[-1].strip()
+        final_query = user_input + ". " + expanded_query.replace('\n', ' ').replace(':', '').strip()
+        final_query = final_query.replace('..', '.').strip()
+        return final_query
+    except Exception:
+        return user_input
+
+def find_job_matches(original_user_query: str, expanded_user_query: str, top_k: int = 50) -> pd.DataFrame:
+    expanded_user_embedding = model.encode(expanded_user_query, convert_to_tensor=True)
+    general_similarity_scores = util.cos_sim(expanded_user_embedding, combined_job_embeddings)[0]
+    top_indices = torch.topk(general_similarity_scores, k=len(combined_df))
+    sorted_combined_df = combined_df.iloc[top_indices.indices.cpu()].copy()
+    sorted_combined_df['general_score'] = top_indices.values.cpu().numpy()
+    unique_matches = sorted_combined_df.drop_duplicates(subset=['job_id'], keep='first').set_index('job_id')
+    original_user_embedding = model.encode(original_user_query, convert_to_tensor=True)
+    title_boost_scores = util.cos_sim(original_user_embedding, original_job_title_embeddings)[0].cpu().numpy()
+    title_boost_map = pd.Series(title_boost_scores, index=original_df['job_id'])
+    unique_matches['title_boost_score'] = unique_matches.index.map(title_boost_map).fillna(0)
+    unique_matches['Similarity Score'] = (0.70 * unique_matches['general_score'] + 0.30 * unique_matches['title_boost_score'])
+    final_job_ids = unique_matches.sort_values(by='Similarity Score', ascending=False).head(top_k).index.tolist()
+    final_results_df = original_df[original_df['job_id'].isin(final_job_ids)].copy()
+    scores_df = unique_matches.reset_index()[['job_id', 'Similarity Score']].copy()
+    final_results_df = pd.merge(final_results_df, scores_df, on='job_id', how='left')
+    final_results_df = final_results_df.sort_values(by='Similarity Score', ascending=False).reset_index(drop=True)
+    final_results_df = final_results_df.set_index('job_id', drop=False).rename(columns={'job_id': 'Job ID'})
+    return final_results_df
+
+def score_jobs_by_skills(user_tokens: list[str], df_to_rank: pd.DataFrame) -> pd.DataFrame:
+    if df_to_rank is None or df_to_rank.empty: return pd.DataFrame()
+    ranked_df = df_to_rank.copy()
+    if 'Skills' not in ranked_df.columns: return ranked_df.sort_values(by='Similarity Score', ascending=False)
+    def calculate_match(row, user_tokens):
+        job_skills = row.get('Skills', [])
+        if not isinstance(job_skills, list): return [], 0, 0.0
+        matched_skills = [s for s in job_skills if any(_skill_match(ut, s) for ut in user_tokens)]
+        total_required_count = len(job_skills)
+        match_score = len(matched_skills) / total_required_count if total_required_count > 0 else 0.0
+        return matched_skills, len(matched_skills), match_score
+    results = ranked_df.apply(lambda row: calculate_match(row, user_tokens), axis=1, result_type='expand')
+    ranked_df[['Skill Matches', 'Skill Match Count', 'Skill Match Score']] = results
+    ranked_df = ranked_df.sort_values(by=['Skill Match Score', 'Similarity Score'], ascending=[False, False]).reset_index(drop=True)
+    return ranked_df.set_index('Job ID', drop=False).rename_axis(None)
+
+# --- REPLACED: Skill extraction now uses spaCy for much better accuracy ---
+def extract_skills_from_text(text: str):
+    global NLP_MODEL
+    if not isinstance(text, str) or not NLP_MODEL:
+        return []
+
+    doc = NLP_MODEL(text)
+    skills = set()
+
+    # Extract named entities that are often skills (e.g., 'Python', 'Amazon Web Services')
+    for ent in doc.ents:
+        if ent.label_ in ["ORG", "PRODUCT", "WORK_OF_ART"]:
+            skills.add(ent.text)
+
+    # Extract noun chunks that look like skills (e.g., 'data analysis')
+    for chunk in doc.noun_chunks:
+        if 1 <= len(chunk.text.split()) <= 4:
+            skills.add(chunk.text)
+
+    # Normalize and apply original filtering logic
+    normalized_skills = [_norm_skill_token(s) for s in skills]
+    junk_phrases = {'demonstrated experience', 'experience', 'related field', 'college/university level', 'equivalent foreign degree', 'cacrep standards', 'students', 'learning experience', 'ability', 'process', 'accreditation', 'human development', 'social welfare', 'sociology', 'pre-service teachers', 'abilities', 'books', 'certifications', 'college', 'level', 'licenses', 'years', 'form', 'knowledge', 'skills'}
+    filtered_skills = [s for s in normalized_skills if s and s not in STOPWORDS and s not in junk_phrases]
+
+    # Deduplicate using stemming
+    stemmed_skills = {}
+    for skill in filtered_skills:
+        stemmed_phrase = ' '.join([stemmer.stem(word) for word in skill.split()])
+        if stemmed_phrase not in stemmed_skills:
+            stemmed_skills[stemmed_phrase] = skill
+
+    return sorted(list(stemmed_skills.values()))
+# --- END REPLACEMENT ---
+
+def initialize_data_and_model():
+    global original_df, combined_df, model, combined_job_embeddings, original_job_title_embeddings, NLP_MODEL
+    print("--- Initializing LLM Client ---")
+    if not initialize_llm_client(): print("Warning: LLM Client failed to initialize.")
+    
+    # --- MODIFIED: Load spaCy model ---
+    print("--- Loading spaCy Model for Skill Extraction ---")
+    try:
+        NLP_MODEL = spacy.load("en_core_web_sm")
+    except Exception as e:
+        print(f"🚨 ERROR loading spaCy model: {e}. Skill extraction will be disabled.")
+    # --- END MODIFICATION ---
+
+    print("--- Loading Datasets ---")
+    ds = datasets.load_dataset("its-zion-18/Jobs-tabular-dataset")
+    original_df = ds["original"].to_pandas()
+    augmented_df = ds["augmented"].to_pandas()
+    original_df['job_id'] = original_df.index
+    max_id = len(original_df) - 1
+    augmented_df['job_id'] = augmented_df.index.map(lambda i: min(i // 20, max_id))
+    def create_full_text(row):
+        return " ".join([str(s) for s in [row.get("Job title"), row.get("Company"), row.get("Duties"), row.get("qualifications"), row.get("Description")]])
+    original_df["full_text"] = original_df.apply(create_full_text, axis=1)
+    augmented_df["full_text"] = augmented_df.apply(create_full_text, axis=1)
+    combined_df = pd.concat([original_df.copy(), augmented_df.copy()], ignore_index=True)
+    original_df = original_df.rename(columns={'Job title': 'job_title', 'Company': 'company'})
+    
+    # --- MODIFIED: Apply new skill extraction function ---
+    print("--- Extracting Skills using spaCy (this may take a moment)... ---")
+    original_df['Skills'] = original_df['qualifications'].apply(extract_skills_from_text)
+    # --- END MODIFICATION ---
+
+    print("--- Loading Fine-Tuned Sentence Transformer Model ---")
+    model = SentenceTransformer(FINETUNED_MODEL_ID)
+    print("--- Encoding Embeddings ---")
+    combined_job_embeddings = model.encode(combined_df["full_text"].tolist(), convert_to_tensor=True, show_progress_bar=True)
+    original_job_title_embeddings = model.encode(original_df["job_title"].tolist(), convert_to_tensor=True, show_progress_bar=True)
+    print("--- Building Vocabulary ---")
+    build_known_vocabulary(combined_df)
+    return "--- Initialization Complete ---"
+
+def _course_links_for(skill: str) -> str:
+    q = _url.quote(skill)
+    links = [("Coursera", f"https://www.coursera.org/search?query={q}"), ("edX", f"https://www.edx.org/search?q={q}"), ("Udemy", f"https://www.udemy.com/courses/search/?q={q}"), ("YouTube", f"https://www.youtube.com/results?search_query={q}+tutorial")]
+    return " • ".join([f'<a href="{u}" target="_blank" style="color: #007bff;">{name}</a>' for name, u in links])
+
+# --- GRADIO INTERFACE FUNCTIONS (No changes needed below this line) ---
+
+def get_job_matches(dream_job: str, top_n: int, skills_text: str):
+    status = "Searching using hybrid model..."
+    expanded_desc = llm_expand_query(dream_job)
+    emb_matches = find_job_matches(dream_job, expanded_desc, top_k=50)
+    user_skills = [_norm_skill_token(s) for s in skills_text.split(',') if _norm_skill_token(s)]
+
+    if user_skills:
+        display_df = score_jobs_by_skills(user_skills, emb_matches)
+    else:
+        display_df = emb_matches
+
+    display_df = display_df.head(top_n)
+
+    if user_skills:
+        status = f"Found and **re-ranked** results by your {len(user_skills)} skills. Displaying top {len(display_df)}."
+    else:
+        status = f"Found {len(display_df)} top matches using semantic search."
+
+    table_to_show = display_df[['job_title', 'company', 'Similarity Score']]
+    if 'Skill Match Score' in display_df.columns:
+        table_to_show['Skill Match Score'] = display_df['Skill Match Score']
+
+    dropdown_options = [(f"{i+1}. {row['job_title']} - {row['company']}", row.name) for i, row in display_df.iterrows()]
+    dropdown_value = dropdown_options[0][1] if dropdown_options else None
+
+    return status, emb_matches, table_to_show, gr.Dropdown(choices=dropdown_options, value=dropdown_value, visible=True), gr.Accordion(visible=True)
+
+def rerank_current_results(initial_matches_df, skills_text, top_n):
+    if initial_matches_df is None or pd.DataFrame(initial_matches_df).empty:
+        return "Please find matches first before re-ranking.", pd.DataFrame(), gr.Dropdown(visible=False)
+
+    initial_matches_df = pd.DataFrame(initial_matches_df)
+
+    user_skills = [_norm_skill_token(s) for s in skills_text.split(',') if _norm_skill_token(s)]
+    if not user_skills:
+        status = "Skills cleared. Showing original semantic search results."
+        display_df = initial_matches_df.head(top_n)
+        table_to_show = display_df[['job_title', 'company', 'Similarity Score']]
+    else:
+        ranked_df = score_jobs_by_skills(user_skills, initial_matches_df)
+        status = f"Results **re-ranked** based on your {len(user_skills)} skills."
+        display_df = ranked_df.head(top_n)
+        table_to_show = display_df[['job_title', 'company', 'Similarity Score', 'Skill Match Score']]
+
+    dropdown_options = [(f"{i+1}. {row['job_title']} - {row['company']}", row.name) for i, row in display_df.iterrows()]
+    dropdown_value = dropdown_options[0][1] if dropdown_options else None
+    return status, table_to_show, gr.Dropdown(choices=dropdown_options, value=dropdown_value, visible=True)
+
+def find_matches_and_rank_with_check(dream_job: str, top_n: int, skills_text: str):
+    if not dream_job:
+        return "Please describe your dream job first.", None, pd.DataFrame(), gr.Dropdown(visible=False), gr.Accordion(visible=False), gr.Markdown(""), gr.Row(visible=False)
+    unrecognized_words = check_spelling_in_query(dream_job)
+    if unrecognized_words:
+        word_list_html = ", ".join([f"<b><span style='color: #F87171;'>{w}</span></b>" for w in unrecognized_words])
+        alert_message = f"<b><span style='color: #F87171;'>⚠️ Possible Spelling Error:</span></b> Unrecognized: {word_list_html}."
+        return "Status: Awaiting confirmation.", None, pd.DataFrame(), gr.Dropdown(visible=False), gr.Accordion(visible=False), gr.Markdown(alert_message, visible=True), gr.Row(visible=True)
+
+    status, emb_matches, table_to_show, dropdown, details_accordion = get_job_matches(dream_job, top_n, skills_text)
+    return status, emb_matches, table_to_show, dropdown, details_accordion, gr.Markdown(visible=False), gr.Row(visible=False)
+
+def find_matches_and_rank_anyway(dream_job: str, top_n: int, skills_text: str):
+    status, emb_matches, table_to_show, dropdown, details_accordion = get_job_matches(dream_job, top_n, skills_text)
+    return status, emb_matches, table_to_show, dropdown, details_accordion, gr.Markdown(visible=False), gr.Row(visible=False)
+
+def on_select_job(job_id, skills_text):
+    if job_id is None:
+        return "", "", "", "", "", gr.Accordion(visible=False), [], 0, gr.Button(visible=False)
+
+    row = original_df.loc[job_id]
+    title, company = str(row.get("job_title", "")), str(row.get("company", ""))
+    job_details_markdown = f"### {title} — {company}"
+    duties, qualifications, description = str(row.get('Duties', '')), str(row.get('qualifications', '')), str(row.get('Description', ''))
+    
+    user_skills = [_norm_skill_token(s) for s in skills_text.split(',') if _norm_skill_token(s)]
+    job_skills = row.get("Skills", [])
+    
+    if not job_skills:
+        learning_plan_html = "<p><i>No specific skills were extracted for this job.</i></p>"
+        return job_details_markdown, duties, qualifications, description, learning_plan_html, gr.Accordion(visible=True), [], 0, gr.Button(visible=False)
+
+    all_missing_skills = sorted([s for s in job_skills if not any(_skill_match(ut, s) for ut in user_skills)], key=lambda x: x.lower())
+    
+    if not all_missing_skills:
+        learning_plan_html = "<h4 style='color:green;'>🎉 You have all the required skills!</h4>"
+        return job_details_markdown, duties, qualifications, description, learning_plan_html, gr.Accordion(visible=True), [], 0, gr.Button(visible=False)
+
+    if user_skills:
+        score_val = (len(job_skills) - len(all_missing_skills)) / len(job_skills)
+        job_details_markdown += f"\n**Your skill match:** {score_val:.1%}"
+        headline = "<b>Great fit!</b>" if score_val >= 0.8 else "<b>Good progress!</b>" if score_val >= 0.5 else "<b>Solid starting point.</b>"
+        learning_plan_html = f"<h4>{headline} Focus on these skills to improve your match:</h4>"
+        skills_to_display = all_missing_skills[:5]
+        items_html = [f"<li><b>{ms}</b><br>• Learn: {_course_links_for(ms)}</li>" for ms in skills_to_display]
+        learning_plan_html += f"<ul style='list-style-type: none; padding-left: 0;'>{''.join(items_html)}</ul>"
+        
+        return job_details_markdown, duties, qualifications, description, learning_plan_html, gr.Accordion(visible=True), [], 0, gr.Button(visible=False)
+
+    else:
+        headline = "<h4>To be a good fit for this role, you'll need to learn these skills:</h4>"
+        skills_to_display = all_missing_skills[:5]
+        items_html = [f"<li><b>{ms}</b><br>• Learn: {_course_links_for(ms)}</li>" for ms in skills_to_display]
+        learning_plan_html = f"{headline}<ul style='list-style-type: none; padding-left: 0;'>{''.join(items_html)}</ul>"
+        
+        full_skill_list_for_state = all_missing_skills
+        new_offset = len(skills_to_display)
+        should_button_be_visible = len(all_missing_skills) > 5
+
+        return job_details_markdown, duties, qualifications, description, learning_plan_html, gr.Accordion(visible=True), full_skill_list_for_state, new_offset, gr.Button(visible=should_button_be_visible)
+
+def load_more_skills(full_skills_list, current_offset):
+    SKILLS_INCREMENT = 5
+    new_offset = current_offset + SKILLS_INCREMENT
+    skills_to_display = full_skills_list[:new_offset]
+    
+    items_html = [f"<li><b>{ms}</b><br>• Learn: {_course_links_for(ms)}</li>" for ms in skills_to_display]
+    learning_plan_html = f"<h4>To be a good fit for this role, you'll need to learn these skills:</h4><ul style='list-style-type: none; padding-left: 0;'>{''.join(items_html)}</ul>"
+
+    should_button_be_visible = new_offset < len(full_skills_list)
+    
+    return learning_plan_html, new_offset, gr.Button(visible=should_button_be_visible)
+
+def on_reset():
+    return ("", 3, "", pd.DataFrame(), None, gr.Dropdown(visible=False), gr.Accordion(visible=False), "Status: Ready.", "", "", "", "", gr.Markdown(visible=False), gr.Row(visible=False), [], 0, gr.Button(visible=False))
+
+# --- Run Initialization ---
+print("Starting application initialization...")
+initialization_status = initialize_data_and_model()
+print(initialization_status)
+
+# --- Gradio Interface Definition ---
+with gr.Blocks(theme=gr.themes.Soft()) as ui:
+    gr.Markdown("# Hybrid Career Planner & Skill Gap Analyzer")
+    
+    initial_matches_state = gr.State()
+    missing_skills_state = gr.State([])
+    skills_offset_state = gr.State(0)
+
+    with gr.Row():
+        with gr.Column(scale=3):
+            dream_text = gr.Textbox(label='Your Dream Job Description', lines=3, placeholder="e.g., 'A role in a tech startup focused on machine learning...'")
+            with gr.Accordion("Optional: Add Your Skills to Re-rank Results", open=False):
+                with gr.Row():
+                    skills_text = gr.Textbox(label='Your Skills (comma-separated)', placeholder="e.g., Python, data analysis", scale=3)
+                    rerank_btn = gr.Button("Re-rank", variant="secondary", scale=1)
+        with gr.Column(scale=1):
+            topk_slider = gr.Slider(minimum=1, maximum=5, value=3, step=1, label="Number of Matches")
+            search_btn = gr.Button("Find Matches", variant="primary")
+            reset_btn = gr.Button("Reset All")
+            
+    status_text = gr.Markdown("Status: Ready.")
+    spelling_alert = gr.Markdown(visible=False)
+    with gr.Row(visible=False) as spelling_row:
+        search_anyway_btn = gr.Button("Search Anyway", variant="secondary")
+        retype_btn = gr.Button("Let Me Fix It", variant="stop")
+        
+    df_output = gr.DataFrame(label="Job Matches", interactive=False)
+    job_selector = gr.Dropdown(label="Select a job to see more details & learning plan:", visible=False)
+    
+    with gr.Accordion("Job Details & Learning Plan", open=False, visible=False) as details_accordion:
+        job_details_markdown = gr.Markdown()
+        
+        with gr.Tabs():
+            with gr.TabItem("Duties"):
+                duties_markdown = gr.Markdown()
+            with gr.TabItem("Qualifications"):
+                qualifications_markdown = gr.Markdown()
+            with gr.TabItem("Full Description"):
+                description_markdown = gr.Markdown()
+        
+        learning_plan_output = gr.HTML(label="Learning Plan")
+        load_more_btn = gr.Button("Load More Skills", visible=False)
+
+    # --- Event Handlers ---
+    search_btn.click(
+        fn=find_matches_and_rank_with_check,
+        inputs=[dream_text, topk_slider, skills_text],
+        outputs=[status_text, initial_matches_state, df_output, job_selector, details_accordion, spelling_alert, spelling_row]
+    )
+    search_anyway_btn.click(
+        fn=find_matches_and_rank_anyway,
+        inputs=[dream_text, topk_slider, skills_text],
+        outputs=[status_text, initial_matches_state, df_output, job_selector, details_accordion, spelling_alert, spelling_row]
+    )
+    retype_btn.click(
+        lambda: ("Status: Ready for you to retype.", None, pd.DataFrame(), gr.Dropdown(visible=False), gr.Accordion(visible=False), gr.Markdown(visible=False), gr.Row(visible=False)),
+        outputs=[status_text, initial_matches_state, df_output, job_selector, details_accordion, spelling_alert, spelling_row]
+    )
+    reset_btn.click(
+        fn=on_reset,
+        outputs=[dream_text, topk_slider, skills_text, df_output, initial_matches_state, job_selector, details_accordion, status_text, job_details_markdown, duties_markdown, qualifications_markdown, description_markdown, spelling_alert, spelling_row, missing_skills_state, skills_offset_state, load_more_btn],
+        queue=False
+    )
+    rerank_btn.click(
+        fn=rerank_current_results,
+        inputs=[initial_matches_state, skills_text, topk_slider],
+        outputs=[status_text, df_output, job_selector]
+    )
+    job_selector.change(
+        fn=on_select_job,
+        inputs=[job_selector, skills_text],
+        outputs=[job_details_markdown, duties_markdown, qualifications_markdown, description_markdown, learning_plan_output, details_accordion, missing_skills_state, skills_offset_state, load_more_btn]
+    )
+    load_more_btn.click(
+        fn=load_more_skills,
+        inputs=[missing_skills_state, skills_offset_state],
+        outputs=[learning_plan_output, skills_offset_state, load_more_btn]
+    )
+
+ui.launch()