Upload 5 files

README.md

@@ -1,14 +1,17 @@
 ---
-title: ASHU AI
-emoji: 📉
-colorFrom: red
-colorTo: red
+title: ASHU AI Mentor Studio
+emoji: 🎓
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.13'
+sdk_version: 4.44.1
 app_file: app.py
 pinned: false
-short_description: ' ASHU AI Mentor Studio'
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ASHU AI Mentor Studio
+
+A Hugging Face native Gradio app for resume/JD analysis, ATS scoring, interview preparation, training plans, document summarization, quiz generation, presenter scripts, scorecards, and architecture diagrams.
+
+This version uses no Docker and no GPU-heavy runtime so it is safer for CPU Basic Spaces.

app.py

@@ -0,0 +1,564 @@
+from __future__ import annotations
+
+import csv
+import datetime as dt
+import io
+import json
+import math
+import os
+import re
+import tempfile
+import textwrap
+import zipfile
+from collections import Counter
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+
+try:
+    import PyPDF2
+except Exception:
+    PyPDF2 = None
+
+try:
+    import docx
+except Exception:
+    docx = None
+
+try:
+    from reportlab.lib import colors
+    from reportlab.lib.pagesizes import A4
+    from reportlab.lib.styles import getSampleStyleSheet
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+except Exception:
+    SimpleDocTemplate = None
+
+APP_TITLE = "ASHU AI Mentor Studio"
+BASE_DIR = Path(__file__).parent.resolve()
+OUT_DIR = BASE_DIR / "outputs"
+OUT_DIR.mkdir(exist_ok=True)
+
+SKILLS = sorted(set('''
+python java c++ javascript typescript sql mysql postgresql mongodb snowflake excel powerbi tableau pandas numpy scipy scikit-learn sklearn tensorflow pytorch keras opencv yolo ultralytics nlp computer vision machine learning deep learning llm rag langchain llamaindex openai huggingface transformers gradio streamlit flask fastapi docker kubernetes git github linux bash aws azure gcp airflow mlflow dvc ci/cd rest api microservices prompt engineering data analysis data science statistics regression classification clustering xgboost lightgbm random forest svm cnn rnn lstm transformer bert gpt vector database faiss chromadb pinecone elasticsearch selenium html css react nodejs django pytest monitoring grafana prometheus agile scrum communication leadership documentation research writing latex
+'''.split()))
+
+STOPWORDS = set('''
+a an the and or but if then else with without for from into onto in on at by to of is are was were be been being this that these those as it its your you we our they them their candidate role job work experience skills using use used will can should could would may might about across within strong good excellent ability knowledge hands-on years year team teams project projects responsibilities requirements preferred required
+'''.split())
+
+
+def clean_text(text: str) -> str:
+    text = text or ""
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def tokens(text: str) -> List[str]:
+    return [t.lower() for t in re.findall(r"[A-Za-z][A-Za-z0-9+.#/-]{1,}", text or "")]
+
+
+def keywords(text: str, n: int = 30) -> List[str]:
+    toks = [t for t in tokens(text) if t not in STOPWORDS and len(t) > 2]
+    counts = Counter(toks)
+    return [w for w, _ in counts.most_common(n)]
+
+
+def detect_skills(text: str) -> List[str]:
+    hay = " " + re.sub(r"[^a-z0-9+#./-]+", " ", (text or "").lower()) + " "
+    found = []
+    for s in SKILLS:
+        pattern = r"(?<![a-z0-9+#./-])" + re.escape(s.lower()) + r"(?![a-z0-9+#./-])"
+        if re.search(pattern, hay):
+            found.append(s)
+    return sorted(found)
+
+
+def read_file(file_obj) -> str:
+    if file_obj is None:
+        return ""
+    path = Path(file_obj.name if hasattr(file_obj, "name") else str(file_obj))
+    suffix = path.suffix.lower()
+    try:
+        if suffix == ".pdf" and PyPDF2 is not None:
+            text_parts = []
+            with open(path, "rb") as f:
+                reader = PyPDF2.PdfReader(f)
+                for page in reader.pages:
+                    text_parts.append(page.extract_text() or "")
+            return clean_text("\n".join(text_parts))
+        if suffix in [".docx", ".doc"] and docx is not None:
+            d = docx.Document(str(path))
+            return clean_text("\n".join(p.text for p in d.paragraphs))
+        if suffix in [".txt", ".md", ".csv"]:
+            return clean_text(path.read_text(encoding="utf-8", errors="ignore"))
+        return clean_text(path.read_text(encoding="utf-8", errors="ignore"))
+    except Exception as e:
+        return f"[Could not read file: {e}]"
+
+
+def safe_filename(prefix: str, ext: str) -> str:
+    ts = dt.datetime.now().strftime("%Y%m%d_%H%M%S")
+    return str(OUT_DIR / f"{prefix}_{ts}.{ext}")
+
+
+def write_text_file(prefix: str, content: str, ext: str = "txt") -> str:
+    path = safe_filename(prefix, ext)
+    Path(path).write_text(content or "", encoding="utf-8")
+    return path
+
+
+def write_csv(prefix: str, rows: List[Dict[str, str]]) -> str:
+    path = safe_filename(prefix, "csv")
+    if not rows:
+        rows = [{"message": "No rows"}]
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
+        writer.writeheader()
+        writer.writerows(rows)
+    return path
+
+
+def write_pdf(prefix: str, title: str, sections: List[Tuple[str, str]]) -> str:
+    path = safe_filename(prefix, "pdf")
+    if SimpleDocTemplate is None:
+        return write_text_file(prefix, "\n\n".join([title] + [f"{h}\n{b}" for h, b in sections]), "txt")
+    styles = getSampleStyleSheet()
+    doc = SimpleDocTemplate(path, pagesize=A4, rightMargin=36, leftMargin=36, topMargin=36, bottomMargin=36)
+    story = [Paragraph(title, styles["Title"]), Spacer(1, 12)]
+    for heading, body in sections:
+        story.append(Paragraph(heading, styles["Heading2"]))
+        for para in textwrap.wrap(clean_text(body), width=95) or [""]:
+            story.append(Paragraph(para, styles["BodyText"]))
+            story.append(Spacer(1, 6))
+        story.append(Spacer(1, 8))
+    doc.build(story)
+    return path
+
+
+def zip_files(prefix: str, files: List[str]) -> str:
+    path = safe_filename(prefix, "zip")
+    with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as z:
+        for f in files:
+            if f and Path(f).exists():
+                z.write(f, arcname=Path(f).name)
+    return path
+
+
+def similarity_score(a: str, b: str) -> float:
+    ka, kb = set(keywords(a, 100)), set(keywords(b, 100))
+    if not ka or not kb:
+        return 0.0
+    return len(ka & kb) / max(1, len(kb))
+
+
+def ats_analyze(resume_file, resume_text: str, jd_text: str, target_role: str):
+    resume = clean_text((resume_text or "") + "\n" + read_file(resume_file))
+    jd = clean_text(jd_text or "")
+    if not resume:
+        return "Upload/paste a resume first.", None
+    if not jd:
+        return "Paste the job description first.", None
+
+    r_skills = detect_skills(resume)
+    j_skills = detect_skills(jd)
+    matched = sorted(set(r_skills) & set(j_skills))
+    missing = sorted(set(j_skills) - set(r_skills))
+    extra = sorted(set(r_skills) - set(j_skills))[:25]
+    keyword_match = similarity_score(resume, jd)
+    skill_score = len(matched) / max(1, len(j_skills))
+    length_score = min(1.0, len(resume.split()) / 450)
+    role_bonus = 0.08 if target_role and target_role.lower() in resume.lower() else 0.0
+    score = round(100 * min(1.0, 0.55 * skill_score + 0.30 * keyword_match + 0.15 * length_score + role_bonus), 1)
+    verdict = "Strong match" if score >= 75 else "Moderate match" if score >= 55 else "Needs tailoring"
+
+    jd_k = keywords(jd, 20)
+    resume_k = keywords(resume, 20)
+    missing_kw = [k for k in jd_k if k not in resume_k][:15]
+
+    md = f"""
+# ATS Resume + JD Analysis
+
+**Target role:** {target_role or 'Not specified'}  
+**ATS-style score:** **{score}/100**  
+**Verdict:** **{verdict}**
+
+## Skill Coverage
+- JD skills detected: {len(j_skills)}
+- Resume skills detected: {len(r_skills)}
+- Matched skills: {len(matched)}
+- Missing JD skills: {len(missing)}
+
+## Matched Skills
+{', '.join(matched) if matched else 'No direct technical skill matches detected.'}
+
+## Missing Skills to Add/Improve
+{', '.join(missing) if missing else 'No major missing skills detected from the built-in skill library.'}
+
+## Resume Skills Not Prominent in JD
+{', '.join(extra) if extra else 'None detected.'}
+
+## Missing JD Keywords
+{', '.join(missing_kw) if missing_kw else 'No important missing JD keywords detected.'}
+
+## Immediate Improvements
+1. Add a short role-aligned summary using the exact job title.
+2. Put matched technical skills in a dedicated skills section.
+3. Add quantified project bullets: problem, model/tool, metric, business impact.
+4. Add missing JD keywords only where truthful.
+5. Keep resume simple: no tables, no image-only text, consistent section headings.
+"""
+    rows = [
+        {"metric": "ATS score", "value": str(score)},
+        {"metric": "matched skills", "value": ", ".join(matched)},
+        {"metric": "missing skills", "value": ", ".join(missing)},
+        {"metric": "missing keywords", "value": ", ".join(missing_kw)},
+    ]
+    csv_path = write_csv("ashu_ats_analysis", rows)
+    pdf_path = write_pdf("ashu_ats_analysis", "ASHU ATS Resume Analysis", [
+        ("Summary", f"Target role: {target_role}. Score: {score}/100. Verdict: {verdict}."),
+        ("Matched Skills", ", ".join(matched) or "None"),
+        ("Missing Skills", ", ".join(missing) or "None"),
+        ("Missing JD Keywords", ", ".join(missing_kw) or "None"),
+        ("Recommendations", "Add role-aligned summary, quantified project bullets, missing truthful keywords, and clean ATS formatting."),
+    ])
+    z = zip_files("ashu_ats_outputs", [csv_path, pdf_path])
+    return md, z
+
+
+def generate_cover_letter(name: str, company: str, role: str, resume_file, resume_text: str, jd_text: str):
+    resume = clean_text((resume_text or "") + "\n" + read_file(resume_file))
+    jd = clean_text(jd_text or "")
+    r_skills = detect_skills(resume)
+    j_skills = detect_skills(jd)
+    matched = sorted(set(r_skills) & set(j_skills))[:10]
+    role = role or "the advertised role"
+    company = company or "your organization"
+    name = name or "Candidate"
+    body = f"""Dear Hiring Team,
+
+I am writing to express my interest in the {role} position at {company}. My background aligns well with the role requirements, especially in {', '.join(matched[:6]) if matched else 'AI, analytics, software development, and problem solving'}.
+
+Across my work, I have focused on building practical solutions that connect technical execution with measurable outcomes. I bring experience in understanding requirements, designing reliable workflows, implementing models or systems, evaluating results, and communicating insights clearly to stakeholders.
+
+What attracts me to this opportunity is the chance to contribute to a team where technical depth, ownership, and impact matter. I would be excited to apply my experience to the problems your team is solving and to keep learning in a high-performance environment.
+
+Thank you for considering my application. I would welcome the opportunity to discuss how my experience can contribute to {company}.
+
+Sincerely,
+{name}
+"""
+    path = write_text_file("ashu_cover_letter", body, "txt")
+    return body, path
+
+
+def interview_questions(role: str, skills: str, difficulty: str, count: int):
+    role = role or "AI/ML Engineer"
+    diff = difficulty or "Medium"
+    skill_list = [s.strip() for s in re.split(r"[,\n]", skills or "") if s.strip()]
+    if not skill_list:
+        skill_list = ["Python", "Machine Learning", "System Design", "Communication"]
+    qs = []
+    for i in range(1, int(count) + 1):
+        s = skill_list[(i - 1) % len(skill_list)]
+        if i % 4 == 1:
+            q = f"Explain a project where you used {s}. What was the problem, your approach, and the final impact?"
+        elif i % 4 == 2:
+            q = f"For a {role}, how would you design a reliable workflow using {s} in production?"
+        elif i % 4 == 3:
+            q = f"What can go wrong while using {s}, and how would you validate or debug it?"
+        else:
+            q = f"Give a {diff.lower()}-level scenario where {s} must be optimized for accuracy, latency, or cost."
+        qs.append({"No.": i, "Question": q, "Difficulty": diff, "Skill": s})
+    df = pd.DataFrame(qs)
+    csv_path = write_csv("ashu_interview_questions", qs)
+    md = "# Interview Questions\n\n" + "\n".join([f"{r['No.']}. **[{r['Skill']}]** {r['Question']}" for r in qs])
+    return md, csv_path
+
+
+def score_answer(question: str, answer: str):
+    q = clean_text(question)
+    a = clean_text(answer)
+    if not q or not a:
+        return "Add both question and answer."
+    qk = set(keywords(q, 20))
+    ak = set(keywords(a, 50))
+    coverage = len(qk & ak) / max(1, len(qk))
+    structure = sum(1 for x in ["problem", "approach", "result", "impact", "metric", "learned"] if x in a.lower()) / 6
+    length = min(1.0, len(a.split()) / 120)
+    score = round(100 * (0.45 * coverage + 0.35 * structure + 0.20 * length), 1)
+    feedback = []
+    if structure < 0.5:
+        feedback.append("Use STAR format: Situation, Task, Action, Result.")
+    if coverage < 0.5:
+        feedback.append("Repeat important terms from the question and answer them directly.")
+    if len(a.split()) < 80:
+        feedback.append("Add more detail and one measurable result.")
+    if not feedback:
+        feedback.append("Good structure. Add one stronger metric if possible.")
+    return f"""# Answer Score: {score}/100
+
+## Feedback
+- """ + "\n- ".join(feedback) + "\n\n## Improved Answer Template\nI handled a situation where **[context]**. My task was **[responsibility]**. I used **[methods/tools]** to solve **[specific problem]**. The result was **[metric/business impact]**. From this, I learned **[lesson]**."
+
+
+def training_plan(goal: str, level: str, weeks: int, hours_per_week: int):
+    goal = goal or "AI/ML and interview preparation"
+    level = level or "Beginner"
+    weeks = int(weeks)
+    hours_per_week = int(hours_per_week)
+    base_topics = keywords(goal, 10)
+    if not base_topics:
+        base_topics = ["python", "machine learning", "projects", "interview"]
+    rows = []
+    md_lines = [f"# {weeks}-Week Training Plan", f"**Goal:** {goal}", f"**Level:** {level}", f"**Time:** {hours_per_week} hours/week", ""]
+    for w in range(1, weeks + 1):
+        topic = base_topics[(w - 1) % len(base_topics)].title()
+        tasks = [
+            f"Learn/revise {topic} fundamentals",
+            f"Build one mini exercise related to {topic}",
+            "Write notes and create 5 flashcards",
+            "Practice 3 interview questions",
+        ]
+        deliverable = f"Week {w} mini output: notes + exercise + interview answers"
+        rows.append({"Week": w, "Topic": topic, "Hours": hours_per_week, "Deliverable": deliverable})
+        md_lines.append(f"## Week {w}: {topic}\n- " + "\n- ".join(tasks) + f"\n- **Deliverable:** {deliverable}\n")
+    csv_path = write_csv("ashu_training_plan", rows)
+    pdf_path = write_pdf("ashu_training_plan", "ASHU Training Plan", [("Plan", "\n".join(md_lines))])
+    z = zip_files("ashu_training_plan", [csv_path, pdf_path])
+    return "\n".join(md_lines), z
+
+
+def summarize_document(file_obj, pasted_text: str, style: str):
+    text = clean_text((pasted_text or "") + "\n" + read_file(file_obj))
+    if not text:
+        return "Upload/paste text first.", None
+    sents = re.split(r"(?<=[.!?])\s+", text)
+    words = keywords(text, 25)
+    selected = []
+    for s in sents:
+        score = sum(1 for w in words if w.lower() in s.lower())
+        if score > 0 and len(s.split()) > 6:
+            selected.append((score, s))
+    selected = [s for _, s in sorted(selected, reverse=True)[:8]]
+    if not selected:
+        selected = sents[:6]
+    if style == "Bullet summary":
+        md = "# Bullet Summary\n" + "\n".join(f"- {clean_text(s)}" for s in selected)
+    elif style == "Study notes":
+        md = "# Study Notes\n\n## Key Terms\n" + ", ".join(words[:15]) + "\n\n## Notes\n" + "\n".join(f"- {clean_text(s)}" for s in selected)
+    else:
+        md = "# Executive Summary\n\n" + " ".join(selected[:5]) + "\n\n## Key Terms\n" + ", ".join(words[:12])
+    path = write_pdf("ashu_summary", "ASHU Document Summary", [("Summary", md)])
+    return md, path
+
+
+def flashcards_mcqs(file_obj, pasted_text: str, count: int):
+    text = clean_text((pasted_text or "") + "\n" + read_file(file_obj))
+    if not text:
+        return "Upload/paste text first.", None
+    kws = keywords(text, int(count) + 10)
+    rows = []
+    md = ["# Flashcards and MCQs"]
+    for i, k in enumerate(kws[:int(count)], 1):
+        rows.append({"type": "flashcard", "question": f"What is {k}?", "answer": f"Explain {k} using the provided material and add one example."})
+        rows.append({"type": "mcq", "question": f"Which statement best relates to {k}?", "answer": "Option A: Most relevant concept from the material."})
+        md.append(f"## {i}. {k.title()}\n**Flashcard:** What is {k}?\n\n**MCQ:** Which statement best relates to {k}?\nA. Most relevant concept from the material\nB. Unrelated term\nC. Random process\nD. None\n\n**Answer:** A\n")
+    csv_path = write_csv("ashu_flashcards_mcqs", rows)
+    return "\n".join(md), csv_path
+
+
+def presenter_script(topic: str, audience: str, minutes: int):
+    topic = topic or "AI Mentor Platform"
+    audience = audience or "students and professionals"
+    minutes = int(minutes)
+    sections = max(3, min(8, minutes // 2 + 1))
+    md = [f"# Digital Presenter Script: {topic}", f"**Audience:** {audience}", f"**Duration:** {minutes} minutes", ""]
+    for i in range(1, sections + 1):
+        md.append(f"## Scene {i}: {['Hook','Problem','Solution','Workflow','Demo','Benefits','Closing','Call to Action'][i-1] if i <= 8 else 'Section'}")
+        md.append(f"Presenter says: Today we discuss **{topic}** for {audience}. In this section, explain the main idea clearly, show one example, and connect it to practical value.\n")
+        md.append(f"On-screen visual: simple title card, diagram, or bullet animation for scene {i}.\n")
+    md.append("## Closing\nThank you. The next step is to test the workflow, collect feedback, and improve the system iteratively.")
+    script = "\n".join(md)
+    path = write_text_file("ashu_presenter_script", script, "md")
+    return script, path
+
+
+def candidate_scorecard(name: str, role: str, resume_file, resume_text: str, interview_notes: str):
+    text = clean_text((resume_text or "") + "\n" + read_file(resume_file) + "\n" + (interview_notes or ""))
+    found = detect_skills(text)
+    dimensions = {
+        "Technical fit": min(100, 30 + len(found) * 5),
+        "Communication": 75 if len((interview_notes or '').split()) > 60 else 55,
+        "Project depth": 80 if any(w in text.lower() for w in ["project", "built", "developed", "implemented"]) else 50,
+        "Role alignment": 85 if role and role.lower() in text.lower() else 60,
+        "Learning potential": 78,
+    }
+    final = round(sum(dimensions.values()) / len(dimensions), 1)
+    rows = [{"Dimension": k, "Score": v} for k, v in dimensions.items()]
+    md = f"# Candidate Scorecard\n\n**Name:** {name or 'Candidate'}  \n**Role:** {role or 'Not specified'}  \n**Final score:** **{final}/100**\n\n"
+    for k, v in dimensions.items():
+        md += f"- **{k}:** {v}/100\n"
+    md += "\n## Detected Strengths\n" + (", ".join(found[:20]) if found else "Add more evidence from resume/interview.")
+    md += "\n\n## Hiring Notes\nProceed if the candidate can explain project ownership, metrics, debugging, and deployment clearly."
+    csv_path = write_csv("ashu_candidate_scorecard", rows)
+    pdf_path = write_pdf("ashu_candidate_scorecard", "ASHU Candidate Scorecard", [("Scorecard", md)])
+    z = zip_files("ashu_candidate_scorecard", [csv_path, pdf_path])
+    return md, z
+
+
+def architecture_diagram(system_name: str, features: str):
+    system_name = system_name or "ASHU AI Mentor Studio"
+    feature_list = [f.strip() for f in re.split(r"[,\n]", features or "") if f.strip()]
+    if not feature_list:
+        feature_list = ["Resume Analyzer", "Training Engine", "Interview Engine", "Report Generator", "Download Center"]
+    nodes = "\n".join([f"    U --> F{i}[{f}]\n    F{i} --> R[Reports and Downloads]" for i, f in enumerate(feature_list, 1)])
+    mermaid = f"""flowchart TD
+    U[User] --> UI[{system_name} UI]
+    UI --> P[Input Processing]
+    P --> K[Keyword and Skill Engine]
+    P --> S[Scoring Engine]
+{nodes}
+    K --> R
+    S --> R
+    R --> D[PDF CSV ZIP Outputs]
+"""
+    md = f"# Architecture Diagram\n\n```mermaid\n{mermaid}\n```\n\n## Components\n" + "\n".join(f"- {f}" for f in feature_list)
+    path = write_text_file("ashu_architecture_mermaid", mermaid, "mmd")
+    return md, path
+
+
+def make_ui():
+    css = """
+    .gradio-container {max-width: 1280px !important}
+    #title-block {text-align:center; padding: 16px; border-radius: 16px; background: linear-gradient(90deg, #eef2ff, #f8fafc);}
+    """
+    with gr.Blocks(title=APP_TITLE, css=css) as demo:
+        gr.Markdown(f"""
+<div id='title-block'>
+<h1>🎓 {APP_TITLE}</h1>
+<p>Full-feature AI mentor app: resume analysis, ATS score, interview prep, training plan, summaries, quiz generation, presenter scripts, scorecards, and diagrams.</p>
+</div>
+""")
+        with gr.Tab("Resume + JD Analyzer"):
+            with gr.Row():
+                resume_file = gr.File(label="Upload Resume PDF/DOCX/TXT")
+                with gr.Column():
+                    role = gr.Textbox(label="Target role", value="AI/ML Engineer")
+                    jd = gr.Textbox(label="Paste Job Description", lines=10)
+                    resume_text = gr.Textbox(label="Or paste resume text", lines=5)
+            btn = gr.Button("Analyze Resume", variant="primary")
+            out = gr.Markdown()
+            file_out = gr.File(label="Download report ZIP")
+            btn.click(ats_analyze, inputs=[resume_file, resume_text, jd, role], outputs=[out, file_out])
+
+        with gr.Tab("Cover Letter"):
+            with gr.Row():
+                cl_name = gr.Textbox(label="Candidate name")
+                cl_company = gr.Textbox(label="Company")
+                cl_role = gr.Textbox(label="Role")
+            cl_resume = gr.File(label="Upload resume")
+            cl_resume_text = gr.Textbox(label="Or paste resume text", lines=5)
+            cl_jd = gr.Textbox(label="Paste JD", lines=8)
+            cl_btn = gr.Button("Generate Cover Letter", variant="primary")
+            cl_out = gr.Textbox(label="Cover letter", lines=16)
+            cl_file = gr.File(label="Download TXT")
+            cl_btn.click(generate_cover_letter, [cl_name, cl_company, cl_role, cl_resume, cl_resume_text, cl_jd], [cl_out, cl_file])
+
+        with gr.Tab("Interview Preparation"):
+            with gr.Row():
+                iq_role = gr.Textbox(label="Role", value="AI/ML Engineer")
+                iq_skills = gr.Textbox(label="Skills comma-separated", value="Python, Machine Learning, SQL, Computer Vision")
+                iq_diff = gr.Dropdown(["Easy", "Medium", "Hard"], value="Medium", label="Difficulty")
+                iq_count = gr.Slider(5, 30, value=10, step=1, label="Number of questions")
+            iq_btn = gr.Button("Generate Questions", variant="primary")
+            iq_out = gr.Markdown()
+            iq_file = gr.File(label="Download CSV")
+            iq_btn.click(interview_questions, [iq_role, iq_skills, iq_diff, iq_count], [iq_out, iq_file])
+
+            gr.Markdown("## Answer Scoring")
+            q_in = gr.Textbox(label="Interview question", lines=3)
+            a_in = gr.Textbox(label="Candidate answer", lines=8)
+            score_btn = gr.Button("Score Answer")
+            score_out = gr.Markdown()
+            score_btn.click(score_answer, [q_in, a_in], score_out)
+
+        with gr.Tab("Training Engine"):
+            with gr.Row():
+                goal = gr.Textbox(label="Training goal", value="Become job-ready in AI, LLMs, RAG, Python and interview preparation")
+                level = gr.Dropdown(["Beginner", "Intermediate", "Advanced"], value="Intermediate", label="Level")
+                weeks = gr.Slider(2, 24, value=8, step=1, label="Weeks")
+                hpw = gr.Slider(2, 20, value=6, step=1, label="Hours/week")
+            tr_btn = gr.Button("Generate Training Plan", variant="primary")
+            tr_out = gr.Markdown()
+            tr_file = gr.File(label="Download ZIP")
+            tr_btn.click(training_plan, [goal, level, weeks, hpw], [tr_out, tr_file])
+
+        with gr.Tab("Document Summarizer"):
+            doc_file = gr.File(label="Upload PDF/DOCX/TXT")
+            doc_text = gr.Textbox(label="Or paste document text", lines=10)
+            style = gr.Dropdown(["Executive summary", "Bullet summary", "Study notes"], value="Bullet summary", label="Summary style")
+            sum_btn = gr.Button("Summarize", variant="primary")
+            sum_out = gr.Markdown()
+            sum_file = gr.File(label="Download PDF/TXT")
+            sum_btn.click(summarize_document, [doc_file, doc_text, style], [sum_out, sum_file])
+
+        with gr.Tab("Flashcards + MCQs"):
+            fc_file = gr.File(label="Upload PDF/DOCX/TXT")
+            fc_text = gr.Textbox(label="Or paste text", lines=10)
+            fc_count = gr.Slider(5, 40, value=12, step=1, label="Number of items")
+            fc_btn = gr.Button("Generate Flashcards + MCQs", variant="primary")
+            fc_out = gr.Markdown()
+            fc_file_out = gr.File(label="Download CSV")
+            fc_btn.click(flashcards_mcqs, [fc_file, fc_text, fc_count], [fc_out, fc_file_out])
+
+        with gr.Tab("Digital Presenter"):
+            pr_topic = gr.Textbox(label="Topic", value="ASHU AI Mentor Platform")
+            pr_aud = gr.Textbox(label="Audience", value="students, recruiters, and training teams")
+            pr_min = gr.Slider(2, 20, value=6, step=1, label="Minutes")
+            pr_btn = gr.Button("Generate Presenter Script", variant="primary")
+            pr_out = gr.Markdown()
+            pr_file = gr.File(label="Download Markdown")
+            pr_btn.click(presenter_script, [pr_topic, pr_aud, pr_min], [pr_out, pr_file])
+
+        with gr.Tab("Candidate Scorecard"):
+            with gr.Row():
+                cand_name = gr.Textbox(label="Candidate name")
+                cand_role = gr.Textbox(label="Role", value="AI/ML Engineer")
+            cand_file = gr.File(label="Upload resume")
+            cand_text = gr.Textbox(label="Or paste resume text", lines=5)
+            cand_notes = gr.Textbox(label="Interview notes / answer transcript", lines=8)
+            cand_btn = gr.Button("Create Scorecard", variant="primary")
+            cand_out = gr.Markdown()
+            cand_zip = gr.File(label="Download ZIP")
+            cand_btn.click(candidate_scorecard, [cand_name, cand_role, cand_file, cand_text, cand_notes], [cand_out, cand_zip])
+
+        with gr.Tab("Architecture Diagrams"):
+            sys_name = gr.Textbox(label="System name", value="ASHU AI Mentor Studio")
+            features = gr.Textbox(label="Features, one per line", value="Resume Analyzer\nATS Score Engine\nTraining Engine\nInterview Engine\nDocument Summarizer\nReport Generator", lines=8)
+            arch_btn = gr.Button("Generate Mermaid Architecture", variant="primary")
+            arch_out = gr.Markdown()
+            arch_file = gr.File(label="Download .mmd")
+            arch_btn.click(architecture_diagram, [sys_name, features], [arch_out, arch_file])
+
+        with gr.Tab("Health Check"):
+            gr.Markdown(f"""
+# ✅ Health Check
+
+- App type: **Native Gradio Space**
+- Heavy GPU modules: **disabled**
+- Docker: **not required**
+- External APIs: **not required**
+- Output folder: `{OUT_DIR}`
+
+If you can see this page, ASHU is running correctly.
+""")
+    return demo
+
+
+demo = make_ui()
+
+if __name__ == "__main__":
+    demo.launch()

assets/.gitkeep

@@ -0,0 +1 @@
+keep

requirements.txt

@@ -0,0 +1,6 @@
+gradio==4.44.1
+pandas==2.2.2
+numpy==1.26.4
+PyPDF2==3.0.1
+python-docx==1.1.2
+reportlab==4.2.2

sample_data/training_catalog.json

@@ -0,0 +1,6 @@
+{
+  "AI/ML": ["Machine Learning", "Deep Learning", "Computer Vision", "NLP", "LLMs", "RAG", "MLOps", "Model Evaluation", "Prompt Engineering", "Responsible AI"],
+  "Data": ["Python", "SQL", "Pandas", "Data Cleaning", "Feature Engineering", "EDA", "Dashboards", "Statistics", "Experiment Design"],
+  "Software": ["APIs", "Microservices", "Git", "Docker", "Testing", "System Design", "Cloud Basics", "Security Basics"],
+  "Career": ["Resume Writing", "Interview Preparation", "Communication", "Leadership", "Presentation", "Research Writing"]
+}