Spaces:
Sleeping
Sleeping
| import json | |
| import re | |
| from pathlib import Path | |
| from difflib import get_close_matches | |
| from collections import OrderedDict | |
| import streamlit as st | |
| import spacy # spaCy for intent detection | |
| from sentence_transformers import SentenceTransformer, util | |
| import torch | |
| # --- Paths --- | |
| ROADMAPS_PATH = Path("roadmaps_fixed.json") | |
| SYNONYMS_PATH = Path("synonyms.json") | |
| # --- Helpers --- | |
| def load_json(path: Path): | |
| if not path.exists(): | |
| return None | |
| with open(path, "r", encoding="utf-8") as f: | |
| return json.load(f) | |
| def save_json(obj, path: Path): | |
| with open(path, "w", encoding="utf-8") as f: | |
| json.dump(obj, f, ensure_ascii=False, indent=2) | |
| # --- Load Data --- | |
| ROADMAPS = load_json(ROADMAPS_PATH) | |
| if ROADMAPS is None: | |
| st.error(f"Missing {ROADMAPS_PATH}. Put your roadmaps JSON in the app directory.") | |
| st.stop() | |
| SYNONYMS = load_json(SYNONYMS_PATH) | |
| # --- Auto-generate synonyms if missing --- | |
| def generate_synonyms_from_skills(skills): | |
| synonyms = {} | |
| for skill in skills: | |
| norm = skill.strip() | |
| low = norm.lower() | |
| synonyms[low] = norm | |
| no_nums = re.sub(r"\d+", "", low).strip() | |
| if no_nums and no_nums != low: | |
| synonyms[no_nums] = norm | |
| if " " in low: | |
| acronym = "".join(w[0] for w in low.split() if w and w[0].isalpha()) | |
| if 1 < len(acronym) <= 6: | |
| synonyms[acronym] = norm | |
| if "javascript" in low: | |
| synonyms["js"] = norm | |
| if "typescript" in low: | |
| synonyms["ts"] = norm | |
| if "python" in low: | |
| synonyms["py"] = norm | |
| if "postgresql" in low: | |
| synonyms["postgres"] = norm | |
| synonyms["pgsql"] = norm | |
| if "mysql" in low: | |
| synonyms["maria"] = norm | |
| if "artificial intelligence" in low: | |
| synonyms["ai"] = norm | |
| if "machine learning" in low: | |
| synonyms["ml"] = norm | |
| if "natural language processing" in low: | |
| synonyms["nlp"] = norm | |
| if "computer vision" in low: | |
| synonyms["cv"] = norm | |
| return synonyms | |
| if SYNONYMS is None: | |
| SYNONYMS = generate_synonyms_from_skills(list(ROADMAPS.keys())) | |
| save_json(SYNONYMS, SYNONYMS_PATH) | |
| SKILLS = list(ROADMAPS.keys()) | |
| SKILLS_LOWER = {s.lower(): s for s in SKILLS} | |
| SYN_LOWER = {k.lower(): v for k, v in SYNONYMS.items()} | |
| STOPWORDS = {"in", "on", "at", "it", "an", "to", "by", "of", "for", "and", "or", "the", "a"} | |
| # --- spaCy Intent Detection --- | |
| nlp = spacy.load("en_core_web_sm") | |
| def detect_intent_spacy(user_text: str) -> str: | |
| if not user_text or not user_text.strip(): | |
| return "default" | |
| doc = nlp(user_text.lower()) | |
| single_keywords = {"single", "one", "combined", "merge"} | |
| separate_keywords = {"separate", "different", "individual", "each"} | |
| for token in doc: | |
| if token.text in single_keywords: | |
| return "single" | |
| if token.text in separate_keywords: | |
| return "separate" | |
| for chunk in doc.noun_chunks: | |
| if "single roadmap" in chunk.text or "one roadmap" in chunk.text: | |
| return "single" | |
| if "separate" in chunk.text or "different" in chunk.text: | |
| return "separate" | |
| for token in doc: | |
| if token.lemma_ in {"merge", "combine", "integrate"}: | |
| return "single" | |
| if token.lemma_ in {"split", "divide"}: | |
| return "separate" | |
| return "default" | |
| # --- Career Path Logic --- | |
| def suggest_career_names(skills): | |
| careers = [] | |
| for skill in skills: | |
| skill = skill.lower() | |
| if skill in ROADMAPS and "careers" in ROADMAPS[skill]: | |
| careers.extend(ROADMAPS[skill]["careers"]) | |
| return list(dict.fromkeys(careers)) # remove duplicates | |
| def suggest_combined_career(skills, domains): | |
| domains_lower = [d.lower() for d in domains] | |
| # --- UI/UX + Development Hybrids --- | |
| if "ui/ux design" in domains_lower and "frontend" in domains_lower: | |
| return "Frontend Developer with Design Expertise" | |
| if "ui/ux design" in domains_lower and "backend & web frameworks" in domains_lower: | |
| return "Full-Stack Developer with UX Focus" | |
| if "ui/ux design" in domains_lower and "programming languages" in domains_lower: | |
| return "Design Technologist" | |
| # --- UI/UX + AI Hybrids --- | |
| if "ui/ux design" in domains_lower and "programming languages" in domains_lower and any("ai" in d for d in domains_lower): | |
| return "AI-Driven Designer" | |
| # --- Development + AI Hybrids --- | |
| if "backend & web frameworks" in domains_lower and any("ai" in d for d in domains_lower): | |
| return "AI-Enhanced Full-Stack Developer" | |
| if "frontend" in domains_lower and any("ai" in d for d in domains_lower): | |
| return "AI-Powered Frontend Engineer" | |
| # --- Mobile + AI Hybrids --- | |
| if "mobile development" in domains_lower and any("ai" in d for d in domains_lower): | |
| return "AI-Powered Mobile Developer" | |
| # --- Cloud/DevOps Hybrids --- | |
| if "cloud computing" in domains_lower and "devops" in domains_lower: | |
| return "Cloud DevOps Engineer" | |
| # --- Web3 --- | |
| if "blockchain development" in domains_lower and "web development" in domains_lower: | |
| return "Web3 Developer" | |
| # --- AI Research --- | |
| if "ai" in domains_lower and "data science" in domains_lower: | |
| return "AI Research Scientist" | |
| # --- AI Infrastructure --- | |
| if "ai" in domains_lower and "cloud computing" in domains_lower: | |
| return "AI Infrastructure Engineer" | |
| return None | |
| # --- Hybrid Roadmap Builder (shortened for brevity) --- | |
| def build_hybrid_roadmap(skills, career_name): | |
| roadmap = OrderedDict() | |
| roadmap["Beginner"] = ["Learn basics of each selected skill", "Project: simple hybrid prototype"] | |
| roadmap["Intermediate"] = ["Combine skills into projects", "Project: hybrid application"] | |
| roadmap["Advanced"] = ["Master frameworks across domains", "Project: large-scale hybrid system"] | |
| roadmap["Expert"] = ["Lead innovation in hybrid domain", "Mentor others in hybrid specialization"] | |
| return roadmap | |
| # --- Embeddings Model --- | |
| embed_model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2") | |
| skills = list(ROADMAPS.keys()) | |
| skill_embeddings = embed_model.encode(skills, convert_to_tensor=True) | |
| # --- Extraction Logic (merged) --- | |
| def extract_skills(user_text: str, threshold: float = 0.6): | |
| found = [] | |
| if not user_text or not user_text.strip(): | |
| return [] | |
| text_lower = user_text.lower() | |
| # --- Keyword & Synonym Matching --- | |
| for skill in SKILLS: | |
| if " " in skill.lower() and skill.lower() in text_lower: | |
| if skill.lower() not in found: | |
| found.append(skill.lower()) | |
| tokens = re.split(r'[,\n; ]+', text_lower) | |
| tokens = [tk.strip() for tk in tokens if tk.strip()] | |
| for tk in tokens: | |
| if not tk or tk in STOPWORDS: | |
| continue | |
| if tk in SYN_LOWER: | |
| mapped = SYN_LOWER[tk].lower() | |
| if mapped in ROADMAPS and mapped not in found: | |
| found.append(mapped) | |
| continue | |
| if tk in SKILLS_LOWER: | |
| mapped = SKILLS_LOWER[tk].lower() | |
| if mapped not in found: | |
| found.append(mapped) | |
| continue | |
| if len(tk) >= 3: | |
| match = get_close_matches(tk, SKILLS_LOWER.keys(), n=1, cutoff=0.75) | |
| if match: | |
| mapped = SKILLS_LOWER[match[0]].lower() | |
| if mapped not in found: | |
| found.append(mapped) | |
| # --- Embeddings Matching --- | |
| user_embedding = embed_model.encode(user_text, convert_to_tensor=True) | |
| cosine_scores = util.cos_sim(user_embedding, skill_embeddings)[0] | |
| for skill, score in zip(skills, cosine_scores): | |
| if float(score) >= threshold and skill.lower() not in found: | |
| found.append(skill.lower()) | |
| return found | |
| # --- Merge multiple roadmaps --- | |
| def merge_roadmaps(skills): | |
| levels = ["beginner", "intermediate", "advanced", "expert"] | |
| merged = OrderedDict() | |
| for lvl in levels: | |
| merged[lvl.capitalize()] = [] | |
| seen = set() | |
| for skill in skills: | |
| if skill not in ROADMAPS: | |
| continue | |
| steps = ROADMAPS[skill].get(lvl, []) | |
| for s in steps: | |
| s_norm = s.strip() | |
| if s_norm and s_norm not in seen: | |
| merged[lvl.capitalize()].append(f"{s_norm} — ({skill})") | |
| seen.add(s_norm) | |
| return merged | |
| # --- Streamlit UI --- | |
| st.set_page_config(page_title="Skill → Roadmap", layout="wide") | |
| st.title("Skill → Roadmap") | |
| user_input = st.text_area( | |
| "Enter your skills (paragraph, comma-separated, or a sentence)", | |
| height=140, | |
| placeholder="e.g. I'm experienced in python, javascript, and figma" | |
| ) | |
| if st.button("Generate roadmap"): | |
| skills = extract_skills(user_input) | |
| domains = [ROADMAPS[s].get("domain", "").lower() for s in skills if s in ROADMAPS] | |
| st.markdown(f"🔎 **Detected skills:** {', '.join(skills) if skills else 'None'}") | |
| intent = detect_intent_spacy(user_input) | |
| want_single = True if intent == "single" else False if intent == "separate" else True | |
| if want_single: | |
| combined_career = suggest_combined_career(skills, domains) | |
| if combined_career: | |
| st.subheader(f"🌍 Hybrid Career Path: {combined_career}") | |
| roadmap = build_hybrid_roadmap(skills, combined_career) | |
| for lvl, steps in roadmap.items(): | |
| st.markdown(f"**{lvl}**") | |
| for step in steps: | |
| st.write(f"- {step}") | |
| else: | |
| merged = merge_roadmaps(skills) | |
| career_names = suggest_career_names(skills) | |
| st.subheader("🌍 Possible Career Paths:") | |
| if career_names: | |
| for c in career_names: | |
| st.markdown(f"- {c}") | |
| else: | |
| st.write("No specific career paths found for these skills.") | |
| st.subheader("📘 Roadmap") | |
| for lvl, steps in merged.items(): | |
| st.markdown(f"**{lvl}**") | |
| for step in steps: | |
| st.write(f"- {step}") | |
| else: | |
| st.subheader("📘 Individual Skill Roadmaps") | |
| if not skills: | |
| st.write("No skills detected.") | |
| for skill in skills: | |
| if skill in ROADMAPS: | |
| st.markdown(f"### {skill} — {ROADMAPS[skill].get('domain','')}") | |
| for lvl, steps in ROADMAPS[skill].items(): | |
| if lvl in {"domain", "careers"}: | |
| continue | |
| st.markdown(f"**{lvl.capitalize()}**") | |
| for s in steps: | |
| st.write(f"- {s}") | |
| else: | |
| st.warning(f"No roadmap found for {skill}") | |