Upload 4 files

app.py

@@ -0,0 +1,244 @@
+import os
+import json
+import re
+import base64
+import tempfile
+import requests
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from models.ocr import extract_text
+from models.skill_extractor import SkillExtractor
+import uvicorn
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# ------------------------------
+# Adzuna API credentials
+# ------------------------------
+ADZUNA_APP_ID = os.getenv("ADZUNA_APP_ID")
+ADZUNA_API_KEY = os.getenv("ADZUNA_API_KEY")
+COUNTRY = "gb"  # Keep as 'gb' to avoid 404
+RESULTS_LIMIT = 5
+
+# ------------------------------
+# Skill extractor & job data
+# ------------------------------
+skill_extractor = SkillExtractor()
+
+with open("jobs_dataset.json", "r") as f:
+    JOBS_DATA = json.load(f)
+
+# ------------------------------
+# Helper functions
+# ------------------------------
+def clean_skills(skills):
+    return list({s.lower().strip() for s in skills if s.strip()})
+
+def predict_role_from_skills(user_skills):
+    if not user_skills:
+        return "Software Developer", 0.0
+
+    user_skills = clean_skills(user_skills)
+    user_text = " ".join(user_skills)
+
+    job_texts = []
+    job_titles = []
+
+    for job in JOBS_DATA:
+        skills = clean_skills(job.get("skills", []))
+        if skills:
+            job_texts.append(" ".join(skills))
+            job_titles.append(job.get("job_title"))
+
+    if not job_texts:
+        return "Software Developer", 0.0
+
+    vectorizer = TfidfVectorizer().fit([user_text] + job_texts)
+    user_vector = vectorizer.transform([user_text])
+    job_vectors = vectorizer.transform(job_texts)
+
+    similarities = cosine_similarity(user_vector, job_vectors)[0]
+    best_idx = similarities.argmax()
+    best_score = similarities[best_idx]
+    best_match = job_titles[best_idx]
+
+    if best_score < 0.1 or not best_match:
+        return "Software Developer", best_score
+
+    return best_match, best_score
+
+def get_missing_skills(user_skills, predicted_role):
+    user_skills = set(clean_skills(user_skills))
+
+    for job in JOBS_DATA:
+        if job.get("job_title") == predicted_role:
+            required_skills = set(clean_skills(job.get("skills", [])))
+            missing = required_skills - user_skills
+            return list(missing)
+
+    return []
+
+# ------------------------------
+# GitHub / LinkedIn extraction
+# ------------------------------
+GITHUB_REGEX = r"(https?://github\.com/[a-zA-Z0-9_-]+)"
+LINKEDIN_REGEX = r"(https?://(www\.)?linkedin\.com/in/[a-zA-Z0-9_-]+)"
+
+def extract_urls(text):
+    github_urls = list(dict.fromkeys(re.findall(GITHUB_REGEX, text)))
+    linkedin_urls = list(dict.fromkeys(re.findall(LINKEDIN_REGEX, text)))
+    return github_urls, linkedin_urls
+
+def fetch_github_readme(github_url):
+    try:
+        parts = github_url.replace("https://github.com/", "").split("/")
+        if len(parts) < 2:
+            return ""
+        user, repo = parts[0], parts[1]
+        api_url = f"https://api.github.com/repos/{user}/{repo}/readme"
+        response = requests.get(api_url)
+        if response.status_code != 200:
+            return ""
+        data = response.json()
+        content = base64.b64decode(data["content"]).decode("utf-8")
+        return content
+    except Exception as e:
+        print("GitHub fetch error:", e)
+        return ""
+
+# ------------------------------
+# Adzuna API Integration
+# ------------------------------
+def get_jobs_from_adzuna(job_title):
+    if not ADZUNA_APP_ID or not ADZUNA_API_KEY:
+        return [{
+            "title": "API Not Configured",
+            "company": "Check HuggingFace Secrets",
+            "location": "-",
+            "link": "#"
+        }]
+
+    url = f"https://api.adzuna.com/v1/api/jobs/{COUNTRY}/search/1"
+    params = {
+        "app_id": ADZUNA_APP_ID,
+        "app_key": ADZUNA_API_KEY,
+        "results_per_page": RESULTS_LIMIT,
+        "what": job_title
+    }
+
+    try:
+        response = requests.get(url, params=params)
+        if response.status_code != 200:
+            return [{"title": f"HTTP Error {response.status_code}", "company": "-", "location": "-", "link": "#"}]
+
+        data = response.json()
+        results = data.get("results", [])
+        jobs = []
+        for job in results:
+            jobs.append({
+                "title": job.get("title", "N/A"),
+                "company": job.get("company", {}).get("display_name", "N/A"),
+                "location": job.get("location", {}).get("display_name", "N/A"),
+                "link": job.get("redirect_url", "#")
+            })
+        if not jobs:
+            jobs.append({"title": "No jobs found", "company": "-", "location": "-", "link": "#"})
+        return jobs
+    except Exception as e:
+        return [{"title": "Exception occurred", "company": str(e), "location": "-", "link": "#"}]
+
+# ------------------------------
+# Resume processing
+# ------------------------------
+def process_resume(file_path):
+    try:
+        text = extract_text(file_path)
+        if not text.strip():
+            return {"error": "No text found."}
+
+        # Extract URLs
+        github_urls, linkedin_urls = extract_urls(text)
+
+        # Extract skills from resume
+        resume_skills = clean_skills(skill_extractor.extract_skills(text))
+
+        # Fetch README text from GitHub
+        github_text = ""
+        for url in github_urls:
+            github_text += fetch_github_readme(url) + "\n"
+
+        github_skills = clean_skills(skill_extractor.extract_skills(github_text)) if github_text else []
+
+        # Predict roles
+        role_resume, score_resume = predict_role_from_skills(resume_skills)
+        role_github, score_github = predict_role_from_skills(github_skills)
+
+        # Missing skills
+        missing_skills_resume = get_missing_skills(resume_skills, role_resume)
+        missing_skills_github = get_missing_skills(github_skills, role_github)
+
+        # Jobs suggestions from Adzuna
+        jobs = get_jobs_from_adzuna(role_resume)
+
+        return {
+            "resume_skills": resume_skills,
+            "github_skills": github_skills,
+            "predicted_role_resume": role_resume,
+            "predicted_role_github": role_github,
+            "similarity_score_resume": round(float(score_resume) * 100, 2),
+            "similarity_score_github": round(float(score_github) * 100, 2),
+            "missing_skills_resume": missing_skills_resume,
+            "missing_skills_github": missing_skills_github,
+            "github_urls": github_urls,
+            "linkedin_urls": linkedin_urls,
+            "jobs": jobs
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+# ------------------------------
+# FastAPI App
+# ------------------------------
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.post("/analyze")
+async def analyze(file: UploadFile = File(None), role: str = Form(None)):
+    if file:
+        tmp = tempfile.NamedTemporaryFile(delete=False)
+        tmp.write(await file.read())
+        tmp.close()
+        result = process_resume(tmp.name)
+        os.remove(tmp.name)
+    elif role:
+        jobs = get_jobs_from_adzuna(role)
+        result = {
+            "resume_skills": [],
+            "github_skills": [],
+            "predicted_role_resume": role,
+            "predicted_role_github": role,
+            "similarity_score_resume": 0.0,
+            "similarity_score_github": 0.0,
+            "missing_skills_resume": [],
+            "missing_skills_github": [],
+            "github_urls": [],
+            "linkedin_urls": [],
+            "jobs": jobs
+        }
+    else:
+        result = {"error": "No file or role provided."}
+
+    return result
+
+# ------------------------------
+# Run App
+# ------------------------------
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

jobs_dataset.json

@@ -0,0 +1,258 @@
+[
+  {
+    "job_title": "Backend Developer",
+    "skills": ["python", "django", "flask", "fastapi", "node.js", "sql", "postgresql", "mongodb", "rest api", "git"]
+  },
+  {
+    "job_title": "Frontend Developer",
+    "skills": ["html", "css", "javascript", "react", "vue", "angular", "typescript", "redux", "tailwind", "ui"]
+  },
+  {
+    "job_title": "Full Stack Developer",
+    "skills": ["python", "django", "react", "node.js", "mongodb", "sql", "rest api", "javascript", "html", "css"]
+  },
+  {
+    "job_title": "Data Scientist",
+    "skills": ["python", "machine learning", "pandas", "numpy", "scikit-learn", "tensorflow", "data analysis", "statistics", "deep learning"]
+  },
+  {
+    "job_title": "Data Analyst",
+    "skills": ["excel", "sql", "power bi", "tableau", "data visualization", "python", "statistics", "reporting"]
+  },
+  {
+    "job_title": "Machine Learning Engineer",
+    "skills": ["python", "tensorflow", "pytorch", "machine learning", "deep learning", "model deployment", "mlops"]
+  },
+  {
+    "job_title": "DevOps Engineer",
+    "skills": ["docker", "kubernetes", "aws", "azure", "ci/cd", "jenkins", "linux", "terraform", "git"]
+  },
+  {
+    "job_title": "Cloud Engineer",
+    "skills": ["aws", "azure", "gcp", "cloud computing", "docker", "kubernetes", "networking", "linux"]
+  },
+  {
+    "job_title": "Cyber Security Analyst",
+    "skills": ["network security", "penetration testing", "ethical hacking", "firewalls", "siem", "risk assessment", "linux"]
+  },
+  {
+    "job_title": "Mobile App Developer",
+    "skills": ["flutter", "react native", "android", "ios", "kotlin", "swift", "firebase", "dart"]
+  },
+  {
+    "job_title": "UI/UX Designer",
+    "skills": ["figma", "adobe xd", "wireframing", "prototyping", "user research", "ui design", "ux design"]
+  },
+  {
+    "job_title": "QA Engineer",
+    "skills": ["manual testing", "automation testing", "selenium", "jira", "test cases", "bug tracking"]
+  },
+  {
+    "job_title": "Blockchain Developer",
+    "skills": ["solidity", "ethereum", "web3", "smart contracts", "blockchain", "cryptography"]
+  },
+  {
+    "job_title": "AI Engineer",
+    "skills": ["python", "machine learning", "deep learning", "nlp", "tensorflow", "pytorch", "llms"]
+  },
+  {
+    "job_title": "Business Analyst",
+    "skills": ["requirement gathering", "documentation", "sql", "stakeholder communication", "data analysis"]
+  },
+  {
+    "job_title": "Software Engineer",
+    "skills": ["java", "c++", "python", "oop", "data structures", "algorithms", "git"]
+  },
+  {
+    "job_title": "Embedded Systems Engineer",
+    "skills": ["c", "c++", "microcontrollers", "arduino", "raspberry pi", "embedded systems"]
+  },
+  {
+    "job_title": "Game Developer",
+    "skills": ["unity", "unreal engine", "c#", "c++", "game design", "3d modeling"]
+  },
+  {
+    "job_title": "Network Engineer",
+    "skills": ["networking", "routing", "switching", "cisco", "firewalls", "tcp/ip"]
+  },
+  {
+    "job_title": "Database Administrator",
+    "skills": ["mysql", "postgresql", "oracle", "database management", "sql tuning", "backup and recovery"]
+  },
+  {
+    "job_title": "Site Reliability Engineer",
+    "skills": ["sre", "monitoring", "prometheus", "grafana", "ci/cd", "incident response"]
+  },
+  {
+    "job_title": "Technical Support Engineer",
+    "skills": ["troubleshooting", "customer support", "linux", "windows", "networking", "ticketing"]
+  },
+  {
+    "job_title": "IT Project Manager",
+    "skills": ["project planning", "scrum", "agile", "stakeholder communication", "risk management"]
+  },
+  {
+    "job_title": "Scrum Master",
+    "skills": ["scrum", "agile coaching", "jira", "team facilitation", "conflict resolution"]
+  },
+  {
+    "job_title": "Solutions Architect",
+    "skills": ["system design", "aws", "azure", "gcp", "scalability", "integration"]
+  },
+  {
+    "job_title": "Product Manager",
+    "skills": ["roadmap planning", "stakeholder communication", "market research", "agile", "requirements"]
+  },
+  {
+    "job_title": "Security Engineer",
+    "skills": ["network security", "encryption", "vulnerability assessment", "siem", "incident response"]
+  },
+  {
+    "job_title": "Penetration Tester",
+    "skills": ["ethical hacking", "metasploit", "burp suite", "vulnerability scanning"]
+  },
+  {
+    "job_title": "Cloud Security Specialist",
+    "skills": ["cloud security", "aws security", "gcp security", "iam", "compliance"]
+  },
+  {
+    "job_title": "Big Data Engineer",
+    "skills": ["hadoop", "spark", "sql", "python", "data pipelines", "etl"]
+  },
+  {
+    "job_title": "Data Architect",
+    "skills": ["data modeling", "sql", "etl", "big data", "data governance"]
+  },
+  {
+    "job_title": "Business Intelligence Developer",
+    "skills": ["power bi", "tableau", "sql", "data visualization", "etl"]
+  },
+  {
+    "job_title": "DevSecOps Engineer",
+    "skills": ["ci/cd", "security automation", "docker", "kubernetes", "aws", "linux"]
+  },
+  {
+    "job_title": "Computer Vision Engineer",
+    "skills": ["opencv", "python", "deep learning", "tensorflow", "image processing"]
+  },
+  {
+    "job_title": "NLP Engineer",
+    "skills": ["nlp", "python", "transformers", "spacy", "bert", "deep learning"]
+  },
+  {
+    "job_title": "Robotics Engineer",
+    "skills": ["robotics", "ros", "c++", "python", "control systems"]
+  },
+  {
+    "job_title": "Augmented Reality Developer",
+    "skills": ["arcore", "arkit", "unity", "3d modeling", "c#"]
+  },
+  {
+    "job_title": "Virtual Reality Developer",
+    "skills": ["unity", "vr hardware", "c#", "3d graphics"]
+  },
+  {
+    "job_title": "Systems Analyst",
+    "skills": ["system requirements", "uml", "business analysis", "testing"]
+  },
+  {
+    "job_title": "IT Consultant",
+    "skills": ["business analysis", "solution design", "stakeholder communication"]
+  },
+  {
+    "job_title": "Hardware Engineer",
+    "skills": ["electronics", "circuit design", "pcb", "embedded systems"]
+  },
+  {
+    "job_title": "Firmware Engineer",
+    "skills": ["c", "c++", "embedded firmware", "rtos", "microcontrollers"]
+  },
+  {
+    "job_title": "Test Automation Engineer",
+    "skills": ["selenium", "cypress", "python", "javascript", "automation frameworks"]
+  },
+  {
+    "job_title": "Performance Test Engineer",
+    "skills": ["jmeter", "loadrunner", "performance tuning"]
+  },
+  {
+    "job_title": "DevOps Architect",
+    "skills": ["ci/cd", "cloud", "docker", "kubernetes", "terraform"]
+  },
+  {
+    "job_title": "Network Security Engineer",
+    "skills": ["firewalls", "vpn", "ids/ips", "network monitoring", "linux"]
+  },
+  {
+    "job_title": "SAP Consultant",
+    "skills": ["sap fico", "sap mm", "sap abap", "business processes"]
+  },
+  {
+    "job_title": "Oracle Developer",
+    "skills": ["oracle", "pl/sql", "sql tuning", "database design"]
+  },
+  {
+    "job_title": "Salesforce Developer",
+    "skills": ["salesforce", "apex", "lightning", "soql"]
+  },
+  {
+    "job_title": "Cloud Solutions Engineer",
+    "skills": ["aws", "azure", "gcp", "infrastructure design", "automation"]
+  },
+  {
+    "job_title": "Kubernetes Administrator",
+    "skills": ["kubernetes", "docker", "helm", "cluster management"]
+  },
+  {
+    "job_title": "Site Reliability Architect",
+    "skills": ["sre principles", "monitoring", "auto scaling", "cloud"]
+  },
+  {
+    "job_title": "Mobile UI Designer",
+    "skills": ["figma", "adobe xd", "responsive design", "interaction design"]
+  },
+  {
+    "job_title": "Frontend Architect",
+    "skills": ["react", "vue", "angular", "performance", "scalability"]
+  },
+  {
+    "job_title": "Web Designer",
+    "skills": ["html", "css", "javascript", "ui/ux", "responsive"]
+  },
+  {
+    "job_title": "Product Designer",
+    "skills": ["figma", "user research", "prototyping", "interaction design"]
+  },
+  {
+    "job_title": "Technical Writer",
+    "skills": ["documentation", "rest api docs", "markdown", "communication"]
+  },
+  {
+    "job_title": "Localization Engineer",
+    "skills": ["translation", "internationalization", "tooling"]
+  },
+  {
+    "job_title": "Cloud Network Engineer",
+    "skills": ["aws networking", "gcp networking", "vpn", "security"]
+  },
+  {
+    "job_title": "IT Auditor",
+    "skills": ["compliance", "risk assessment", "audit reporting"]
+  },
+  {
+    "job_title": "Help Desk Technician",
+    "skills": ["support", "troubleshooting", "ticketing", "communication"]
+  },
+  {
+    "job_title": "Security Operations Center Analyst",
+    "skills": ["siem", "incident response", "monitoring"]
+  },
+  {
+    "job_title": "AI Research Scientist",
+    "skills": ["deep learning", "nlp", "python", "research"]
+  },
+  {
+    "job_title": "Augmented Analytics Specialist",
+    "skills": ["ai analytics", "data visualization", "python"]
+  }
+]

requirements.txt

@@ -0,0 +1,10 @@
+gradio
+spacy
+huggingface_hub
+PyMuPDF
+easyocr
+scikit-learn
+fastapi
+uvicorn
+python-multipart
+PyPDF2