Similarity Search

from Oyemi import semantic_similarity

# Compare skill pairs (same semantic category = high similarity)
pairs = [
    ("programming", "coding"),         # Same superclass
    ("management", "supervision"),    # Same superclass
    ("analysis", "research"),         # Same superclass
    ("teamwork", "collaboration"),   # Same superclass
    ("python", "programming"),       # Different superclass
]

print("Skill Similarity Scores:")
for skill1, skill2 in pairs:
    sim = semantic_similarity(skill1, skill2)
    print(f"  {skill1:15} <-> {skill2:15}: {sim:.2f}")

from Oyemi import find_synonyms, Encoder

def expand_skills(skills, limit=3):
    """Expand skill list with synonyms for broader matching"""
    expanded = set(skills)

    for skill in skills:
        try:
            synonyms = find_synonyms(skill, limit=limit)
            expanded.update(synonyms)
        except:
            pass  # Skill not in lexicon

    return list(expanded)

# Expand job requirements
job_skills = ["leadership", "planning", "communication"]
expanded = expand_skills(job_skills)

print("Original skills:", job_skills)
print("Expanded skills:", expanded[:10])

from Oyemi import semantic_similarity, find_synonyms
import numpy as np

def match_resume_to_job(candidate_skills, job_skills):
    """Calculate semantic match score between candidate and job"""

    match_scores = []
    matched_skills = []

    for job_skill in job_skills:
        best_match = 0
        best_candidate_skill = None

        for candidate_skill in candidate_skills:
            try:
                sim = semantic_similarity(job_skill, candidate_skill)
                if sim > best_match:
                    best_match = sim
                    best_candidate_skill = candidate_skill
            except:
                continue

        match_scores.append(best_match)
        if best_match > 0.6:  # Threshold for "match"
            matched_skills.append((job_skill, best_candidate_skill, best_match))

    return {
        'overall_score': np.mean(match_scores),
        'coverage': len(matched_skills) / len(job_skills),
        'matched_skills': matched_skills
    }

# Test with matching skill pairs
job = ["programming", "analysis", "teamwork", "planning"]
candidate = ["coding", "research", "collaboration", "coordination"]

result = match_resume_to_job(candidate, job)
print(f"Match Score: {result['overall_score']:.2f}")
print(f"Skill Coverage: {result['coverage']:.0%}")
print("Matched Skills:")
for job_s, cand_s, score in result['matched_skills']:
    print(f"  {job_s} <- {cand_s} ({score:.2f})")

# Define candidates and jobs
candidates = {
    "Alice Chen": ["python", "analytics", "modeling", "visualization"],
    "Bob Smith": ["react", "typescript", "ui design", "frontend"],
    "Carol Davis": ["management", "coordination", "scheduling", "presenting"],
}

jobs = {
    "Data Scientist": ["python", "machine learning", "statistics", "analysis"],
    "Frontend Dev": ["javascript", "react", "css", "responsive"],
    "Project Manager": ["leadership", "planning", "communication", "teamwork"],
}

# Match each candidate to each job
for job_title, job_skills in jobs.items():
    print(f"\n=== {job_title} ===")

    rankings = []
    for name, skills in candidates.items():
        result = match_resume_to_job(skills, job_skills)
        rankings.append((name, result['overall_score'], result['coverage']))

    # Sort by score
    rankings.sort(key=lambda x: x[1], reverse=True)

    for rank, (name, score, coverage) in enumerate(rankings, 1):
        print(f"  {rank}. {name}: {score:.2f} ({coverage:.0%} coverage)")

from Oyemi import find_synonyms, find_similar

def expand_search_query(query_terms, expansion_limit=5):
    """Expand search query with semantically similar terms"""

    expanded_query = set(query_terms)
    expansions = {}

    for term in query_terms:
        try:
            # Get synonyms
            synonyms = find_synonyms(term, limit=expansion_limit)
            expanded_query.update(synonyms)
            expansions[term] = synonyms
        except:
            expansions[term] = []

    return list(expanded_query), expansions

# Expand a job search query
search_terms = ["manager", "leadership", "salary"]
expanded, details = expand_search_query(search_terms)

print("Original query:", search_terms)
print("\nExpansions:")
for term, synonyms in details.items():
    print(f"  {term}: {synonyms}")
print(f"\nExpanded query ({len(expanded)} terms):", expanded[:12])