updated resume_format > template, hide sidebar, download Spacy model with spacy_loader.py

.streamlit/config.toml

@@ -6,4 +6,8 @@ textColor="#262730"
 font="sans serif"
 
 [ui]
-sidebarState = "collapsed"
+hideTopBar = false
+hideSidebarNav = true
+
+[server]
+headless = true

README.md

@@ -15,7 +15,7 @@ Check out the configuration reference at https://huggingface.co/docs/hub/spaces-
 
 TalentLensAI is an AI-powered resume screening and evaluation tool that leverages Hugging Face models for summarization and scoring. It integrates with Supabase for candidate data storage and utilizes Streamlit for an interactive user interface.
 
-Features
+## Features
 
 Resume Summarization: Uses Facebook's BART model (facebook/bart-large-cnn) to generate a concise summary of the resume.
 
@@ -27,7 +27,24 @@ PDF Report Generation: Generates a PDF report summarizing the evaluation results
 
 Streamlit UI: Provides a user-friendly interface for uploading resumes and reviewing results.
 
-Setup Instructions
+## Deployment Notes
+
+### SpaCy Model Handling
+The application uses spaCy for natural language processing. To handle deployment environments where the `en_core_web_sm` model might not be available:
+
+- The spaCy model is automatically downloaded via requirements.txt
+- A fallback system (`utils/spacy_loader.py`) provides graceful degradation
+- If spaCy is unavailable, the system uses regex-based extraction methods
+
+### Hugging Face Spaces Deployment
+For Hugging Face Spaces deployment, the following files are configured:
+
+- `requirements.txt`: Includes direct spaCy model download link
+- `packages.txt`: System dependencies for spaCy compilation
+- `utils/spacy_loader.py`: Robust model loading with fallbacks
+- NumPy version pinned to `<2.0` for compatibility
+
+## Setup Instructions
 
 1. Clone the Repository
 ```

Template.py

@@ -0,0 +1,359 @@
+# pages/Format_Resume.py
+
+import os, sys, streamlit as st
+import json
+from io import BytesIO
+
+# Add parent directory to path so we can import utils
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Force reload environment variables for Streamlit
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+from utils.hybrid_extractor import extract_resume_sections
+from utils.builder   import build_resume_from_data
+from utils.parser import parse_resume            # whatever parse_resume you already have
+
+# Path to your blank template (header/footer only)
+template_path = os.path.join(
+    os.path.dirname(__file__), '..', 'templates', 'blank_resume.docx'
+)
+
+st.set_page_config(
+    page_title='Resume Formatter', 
+    layout='centered',
+    initial_sidebar_state="collapsed"
+)
+
+# Hide sidebar completely with CSS
+st.markdown("""
+    <style>
+        .css-1d391kg {display: none}
+        .css-1rs6os {display: none}
+        .css-17ziqus {display: none}
+        [data-testid="stSidebar"] {display: none}
+        [data-testid="collapsedControl"] {display: none}
+        .css-1lcbmhc {display: none}
+        .css-1outpf7 {display: none}
+        .sidebar .sidebar-content {display: none}
+    </style>
+""", unsafe_allow_html=True)
+
+# Home button at the top
+if st.button("🏠 Home", help="Return to main TalentLens.AI page"):
+    st.switch_page("app.py")
+
+st.title('📄 Resume Formatter')
+st.markdown("---")
+
+uploaded = st.file_uploader('Upload Resume (PDF or DOCX)', type=['pdf','docx'])
+if not uploaded:
+    st.info("Please upload a resume to get started.")
+    
+    # Show help information when no file is uploaded
+    st.markdown("### 💡 How to Use Resume Formatter")
+    st.markdown("""
+    1. **Upload your resume** in PDF or DOCX format
+    2. **Review extracted data** - our AI will parse your resume sections
+    3. **Edit if needed** - make any corrections to the extracted information
+    4. **Generate formatted resume** - download a professionally formatted version
+    """)
+    
+    st.markdown("### ✨ Features")
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown("""
+        **🤖 AI-Powered Extraction:**
+        - OpenAI GPT-4o for highest accuracy
+        - Hugging Face Cloud as backup
+        - Regex fallback for reliability
+        """)
+    with col2:
+        st.markdown("""
+        **📄 Professional Formatting:**
+        - Clean, modern design
+        - Consistent layout
+        - ATS-friendly format
+        """)
+    
+    st.stop()
+
+st.success(f'Uploaded: {uploaded.name}')
+
+# 1) Extract raw text
+ext = uploaded.name.split('.')[-1].lower()
+resume_text = parse_resume(uploaded, ext)
+
+st.subheader('📄 Raw Resume Text')
+st.text_area(
+    label='Raw Resume Text',
+    value=resume_text,
+    height=300,
+    label_visibility='visible'
+)
+
+# 2) Parse into structured fields using improved hybrid approach
+st.subheader('🔍 Extracting Resume Data...')
+
+# Show extraction progress
+with st.spinner('Analyzing resume with AI models...'):
+    # Use OpenAI as primary, HF Cloud as backup
+    data = extract_resume_sections(
+        resume_text, 
+        prefer_ai=True, 
+        use_openai=True,      # Try OpenAI GPT-4o first (best results)
+        use_hf_cloud=True     # Fallback to HF Cloud (good backup)
+    )
+
+# Show extraction success and method used
+from utils.hybrid_extractor import HybridResumeExtractor
+extractor = HybridResumeExtractor(prefer_ai=True, use_openai=True, use_hf_cloud=True)
+extractor.extract_sections(resume_text)  # Just to get the method used
+stats = extractor.get_extraction_stats()
+
+method_used = stats.get('method_used', 'unknown')
+if method_used == 'openai_gpt4o':
+    st.success('✅ Extracted using OpenAI GPT-4o (highest accuracy)')
+elif method_used == 'huggingface_cloud':
+    st.info('ℹ️ Extracted using Hugging Face Cloud (good accuracy)')
+else:
+    st.warning('⚠️ Used fallback extraction method')
+
+# Show extraction quality indicators
+name_found = bool(data.get('Name'))
+experiences_found = len(data.get('StructuredExperiences', []))
+skills_found = len(data.get('Skills', []))
+
+col1, col2, col3 = st.columns(3)
+with col1:
+    st.metric("Name", "✅" if name_found else "❌", "Found" if name_found else "Missing")
+with col2:
+    st.metric("Job Experiences", experiences_found, f"{experiences_found} positions")
+with col3:
+    st.metric("Technical Skills", skills_found, f"{skills_found} skills")
+
+# 👇 TEMP – remove after test (show raw JSON for debugging)
+with st.expander("🔧 Debug: Raw Extraction Data"):
+    import json, textwrap
+    st.code(textwrap.indent(json.dumps(data, indent=2), "  "), language="json")
+
+st.subheader('📋 Parsed Resume Sections')
+
+# Display sections in a more user-friendly way
+col1, col2 = st.columns(2)
+
+with col1:
+    # Name and Summary
+    st.markdown("**👤 Personal Information**")
+    if data.get('Name'):
+        st.write(f"**Name:** {data['Name']}")
+    else:
+        st.error("❌ Name not found")
+    
+    if data.get('Summary'):
+        st.markdown("**📝 Professional Summary:**")
+        st.write(data['Summary'])
+    else:
+        st.warning("⚠️ No professional summary found")
+    
+    # Education
+    st.markdown("**🎓 Education**")
+    education = data.get('Education', [])
+    if education:
+        for edu in education:
+            st.write(f"• {edu}")
+    else:
+        st.warning("⚠️ No education information found")
+
+with col2:
+    # Skills
+    st.markdown("**🛠️ Technical Skills**")
+    skills = data.get('Skills', [])
+    if skills:
+        # Show skills in a nice format
+        skills_text = ", ".join(skills)
+        st.write(skills_text)
+        
+        # Show skills quality
+        company_names = [s for s in skills if any(word in s.lower() for word in ['abc', 'xyz', 'financial', 'insurance', 'solutions'])]
+        if company_names:
+            st.warning(f"⚠️ Found {len(company_names)} company names in skills (will be cleaned)")
+    else:
+        st.error("❌ No technical skills found")
+    
+    # Training/Certifications
+    training = data.get('Training', [])
+    if training:
+        st.markdown("**📜 Certifications/Training**")
+        for cert in training:
+            st.write(f"• {cert}")
+
+# Work Experience (full width)
+st.markdown("**💼 Professional Experience**")
+experiences = data.get('StructuredExperiences', [])
+if experiences:
+    for i, exp in enumerate(experiences, 1):
+        with st.expander(f"Job {i}: {exp.get('title', 'Unknown Title')} at {exp.get('company', 'Unknown Company')}"):
+            st.write(f"**Position:** {exp.get('title', 'N/A')}")
+            st.write(f"**Company:** {exp.get('company', 'N/A')}")
+            st.write(f"**Duration:** {exp.get('date_range', 'N/A')}")
+            
+            responsibilities = exp.get('responsibilities', [])
+            if responsibilities:
+                st.write("**Key Responsibilities:**")
+                for resp in responsibilities:
+                    st.write(f"• {resp}")
+            else:
+                st.warning("⚠️ No responsibilities found for this position")
+else:
+    st.error("❌ No work experience found")
+
+# Show editable sections for user to modify if needed
+st.subheader('✏️ Edit Extracted Data (Optional)')
+with st.expander("Click to edit extracted data before formatting"):
+    for section, content in data.items():
+        st.markdown(f"**{section}:**")
+
+        # pure list of strings
+        if isinstance(content, list) and all(isinstance(i, str) for i in content):
+            edited_content = st.text_area(
+                label=section,
+                value="\n".join(content),
+                height=100,
+                label_visibility='collapsed',
+                key=f"edit_{section}"
+            )
+            # Update data with edited content
+            data[section] = [line.strip() for line in edited_content.split('\n') if line.strip()]
+
+        # list of dicts → show as JSON (read-only for now)
+        elif isinstance(content, list) and all(isinstance(i, dict) for i in content):
+            st.json(content)
+
+        # everything else (e.g. single string)
+        else:
+            edited_content = st.text_area(
+                label=section,
+                value=str(content),
+                height=100,
+                label_visibility='collapsed',
+                key=f"edit_{section}_str"
+            )
+            # Update data with edited content
+            data[section] = edited_content
+
+# 3) Build & download
+st.subheader('📄 Generate Formatted Resume')
+
+# Show what will be included in the formatted resume
+col1, col2, col3 = st.columns(3)
+with col1:
+    st.metric("Sections to Include", len([k for k, v in data.items() if v]), "sections")
+with col2:
+    total_content = sum(len(str(v)) for v in data.values() if v)
+    st.metric("Content Length", f"{total_content:,}", "characters")
+with col3:
+    quality_score = (
+        (1 if data.get('Name') else 0) +
+        (1 if data.get('Summary') else 0) +
+        (1 if data.get('StructuredExperiences') else 0) +
+        (1 if data.get('Skills') else 0)
+    ) * 25
+    st.metric("Quality Score", f"{quality_score}%", "completeness")
+
+if st.button('📄 Generate Formatted Resume', type='primary'):
+    try:
+        with st.spinner('Building formatted resume...'):
+            # Build the resume document
+            doc = build_resume_from_data(template_path, data)
+            
+            # Save to buffer
+            buf = BytesIO()
+            doc.save(buf)
+            buf.seek(0)
+
+        st.success('✅ Resume formatted successfully!')
+        
+        # Show what was included
+        st.info(f"""
+        **Formatted Resume Includes:**
+        • Name: {data.get('Name', 'Not found')}
+        • Professional Summary: {'✅' if data.get('Summary') else '❌'}
+        • Technical Skills: {len(data.get('Skills', []))} items
+        • Work Experience: {len(data.get('StructuredExperiences', []))} positions
+        • Education: {len(data.get('Education', []))} items
+        """)
+        
+        # Generate filename with candidate name
+        candidate_name = data.get('Name', 'Resume').replace(' ', '_')
+        filename = f"{candidate_name}_Formatted_Resume.docx"
+        
+        st.download_button(
+            '📥 Download Formatted Resume',
+            data=buf,
+            file_name=filename,
+            mime='application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            help=f"Download the formatted resume for {data.get('Name', 'candidate')}"
+        )
+        
+    except Exception as e:
+        st.error(f"❌ Error generating formatted resume: {str(e)}")
+        st.info("💡 Try editing the extracted data above to fix any issues, or contact support if the problem persists.")
+
+# Add helpful tips
+with st.expander("💡 Tips for Better Results"):
+    st.markdown("""
+    **For best extraction results:**
+    - Ensure your resume has clear section headers (e.g., "Professional Summary", "Technical Skills", "Work Experience")
+    - Use consistent formatting for job entries (Title | Company | Dates)
+    - List technical skills clearly, separated by commas
+    - Include bullet points for job responsibilities
+    
+    **If extraction isn't perfect:**
+    - Use the "Edit Extracted Data" section above to make corrections
+    - The system will learn from different resume formats over time
+    - OpenAI GPT-4o provides the most accurate extraction when available
+    """)
+
+# Show extraction method info
+with st.expander("🔧 Extraction Method Details"):
+    st.markdown(f"""
+    **Method Used:** {method_used}
+    
+    **Available Methods:**
+    - **OpenAI GPT-4o**: Highest accuracy, best for complex formats
+    - **Hugging Face Cloud**: Good accuracy, reliable backup
+    - **Regex Fallback**: Basic extraction, used when AI methods fail
+    
+    **Current Status:**
+    - OpenAI Available: {'✅' if stats.get('ai_available') else '❌'}
+    - AI Preferred: {'✅' if stats.get('prefer_ai') else '❌'}
+    """)
+
+# Footer navigation and additional actions
+st.markdown("---")
+st.markdown("### 🚀 What's Next?")
+
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    if st.button("🏠 Return to Home", use_container_width=True):
+        st.switch_page("app.py")
+
+with col2:
+    if st.button("📄 Format Another Resume", use_container_width=True):
+        st.rerun()
+
+with col3:
+    st.markdown("**Need Help?**")
+    st.markdown("Check the tips above or contact support")
+
+# Final footer
+st.markdown("---")
+st.markdown(
+    "<div style='text-align: center; color: #666; padding: 20px;'>"
+    "🚀 <strong>TalentLens.AI</strong> - Powered by AI for intelligent resume processing"
+    "</div>", 
+    unsafe_allow_html=True
+)

app.py

@@ -18,7 +18,25 @@ from utils.reporting import generate_pdf_report, generate_interview_questions_fr
 
 # ------------------------- Main App Function -------------------------
 def main():
-    st.set_page_config(page_title="TalentLens.AI", layout="centered")
+    st.set_page_config(
+        page_title="TalentLens.AI", 
+        layout="centered",
+        initial_sidebar_state="collapsed"
+    )
+
+    # Hide sidebar completely with CSS
+    st.markdown("""
+        <style>
+            .css-1d391kg {display: none}
+            .css-1rs6os {display: none}
+            .css-17ziqus {display: none}
+            [data-testid="stSidebar"] {display: none}
+            [data-testid="collapsedControl"] {display: none}
+            .css-1lcbmhc {display: none}
+            .css-1outpf7 {display: none}
+            .sidebar .sidebar-content {display: none}
+        </style>
+    """, unsafe_allow_html=True)
 
     st.markdown("<h1 style='text-align: center;'>TalentLens.AI</h1>", unsafe_allow_html=True)
     st.divider()
@@ -38,8 +56,23 @@ def main():
     # Input job description
     job_description = st.text_area("Enter Job Description")
 
-    # Evaluation trigger
-    if st.button("Evaluate Resumes"):
+    # Main action buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Evaluation trigger
+        evaluate_clicked = st.button("📊 Evaluate Resumes", type="primary", use_container_width=True)
+    
+    with col2:
+        # Format Resume redirect button
+        format_clicked = st.button("📄 Format Resume", use_container_width=True)
+
+    # Handle Format Resume redirect
+    if format_clicked:
+        st.switch_page("pages/Template.py")
+
+    # Handle Evaluate Resumes
+    if evaluate_clicked:
         if not job_description:
             st.error("⚠️ Please enter a job description.")
             return

app_startup.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+Startup script for Hugging Face Spaces deployment
+Ensures spaCy model is available before starting the main app
+"""
+
+import subprocess
+import sys
+import os
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def install_spacy_model():
+    """Install spaCy English model if not already available"""
+    try:
+        import spacy
+        
+        # Try to load the model
+        try:
+            nlp = spacy.load("en_core_web_sm")
+            logger.info("✅ spaCy model 'en_core_web_sm' is already available")
+            return True
+        except OSError:
+            logger.info("📦 spaCy model 'en_core_web_sm' not found, downloading...")
+            
+        # Download the model
+        subprocess.check_call([
+            sys.executable, "-m", "spacy", "download", "en_core_web_sm"
+        ])
+        
+        # Verify installation
+        nlp = spacy.load("en_core_web_sm")
+        logger.info("✅ spaCy model 'en_core_web_sm' downloaded and loaded successfully")
+        return True
+        
+    except subprocess.CalledProcessError as e:
+        logger.error(f"❌ Failed to download spaCy model: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"❌ Error setting up spaCy: {e}")
+        return False
+
+def main():
+    """Main startup function"""
+    logger.info("🚀 Starting TalentLens.AI...")
+    
+    # Install spaCy model
+    model_success = install_spacy_model()
+    
+    if not model_success:
+        logger.warning("⚠️ spaCy model not available, application will use fallback methods")
+    
+    # Import and run the main app
+    try:
+        from app import main as app_main
+        logger.info("✅ Starting Streamlit app...")
+        app_main()
+    except Exception as e:
+        logger.error(f"❌ Failed to start main app: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

packages.txt

@@ -0,0 +1,2 @@
+build-essential
+python3-dev 

pages/{Format_Resume.py → Template.py}

@@ -1,4 +1,4 @@
-# pages/Format_Resume.py
+# pages/Template.py
 
 import os, sys, streamlit as st
 import json
@@ -20,8 +20,32 @@ template_path = os.path.join(
     os.path.dirname(__file__), '..', 'templates', 'blank_resume.docx'
 )
 
-st.set_page_config(page_title='Resume Formatter', layout='centered')
-st.title('📄 Resume Formatter')
+st.set_page_config(
+    page_title='Resume Template Builder', 
+    layout='centered',
+    initial_sidebar_state="collapsed"
+)
+
+# Hide sidebar completely with CSS
+st.markdown("""
+    <style>
+        .css-1d391kg {display: none}
+        .css-1rs6os {display: none}
+        .css-17ziqus {display: none}
+        [data-testid="stSidebar"] {display: none}
+        [data-testid="collapsedControl"] {display: none}
+        .css-1lcbmhc {display: none}
+        .css-1outpf7 {display: none}
+        .sidebar .sidebar-content {display: none}
+    </style>
+""", unsafe_allow_html=True)
+
+# Home button at the top
+if st.button("🏠 Home", help="Return to main TalentLens.AI page"):
+    st.switch_page("app.py")
+
+st.title('📄 Resume Template Builder')
+st.markdown("---")
 
 uploaded = st.file_uploader('Upload Resume (PDF or DOCX)', type=['pdf','docx'])
 if not uploaded:
@@ -279,3 +303,30 @@ with st.expander("🔧 Extraction Method Details"):
     - OpenAI Available: {'✅' if stats.get('ai_available') else '❌'}
     - AI Preferred: {'✅' if stats.get('prefer_ai') else '❌'}
     """)
+
+# Footer navigation and additional actions
+st.markdown("---")
+st.markdown("### 🚀 What's Next?")
+
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    if st.button("🏠 Return to Home", use_container_width=True):
+        st.switch_page("app.py")
+
+with col2:
+    if st.button("📄 Format Another Resume", use_container_width=True):
+        st.rerun()
+
+with col3:
+    st.markdown("**Need Help?**")
+    st.markdown("Check the tips above or contact support")
+
+# Final footer
+st.markdown("---")
+st.markdown(
+    "<div style='text-align: center; color: #666; padding: 20px;'>"
+    "🚀 <strong>TalentLens.AI</strong> - Powered by AI for intelligent resume processing"
+    "</div>", 
+    unsafe_allow_html=True
+) 

requirements.txt

@@ -6,7 +6,8 @@ PyMuPDF
 pytest
 sentence-transformers
 spacy
+https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl
 openai
 fuzzywuzzy
 python-docx
-numpy
+numpy<2.0

utils/extractor_fixed.py

@@ -1,26 +1,37 @@
-import os, re, json, subprocess, spacy
-from spacy.matcher import PhraseMatcher, Matcher
+import os, re, json, subprocess
 from utils.parser import extract_name        # <= your helper
+from utils.spacy_loader import get_nlp, is_spacy_available
 from datetime import datetime
 from dateutil.parser import parse as date_parse
 
-nlp = spacy.load("en_core_web_sm")           # assume already downloaded
+# Load spaCy model with fallback
+nlp = get_nlp()
 
-# ----------------------------- data lists -----------------------------
-BASE = os.path.dirname(__file__)
-SKILLS      = json.load(open(os.path.join(BASE, "data/skills.json")))   \
-              if os.path.exists(os.path.join(BASE,"data/skills.json"))  \
-              else ["python","sql","aws","selenium"]
-JOB_TITLES  = json.load(open(os.path.join(BASE, "data/job_titles.json")))\
-              if os.path.exists(os.path.join(BASE,"data/job_titles.json"))\
-              else []
-
-skill_matcher = PhraseMatcher(nlp.vocab, attr="LOWER")
-skill_matcher.add("SKILL", [nlp.make_doc(s) for s in SKILLS])
-
-edu_matcher = Matcher(nlp.vocab)
-edu_matcher.add("EDU" , [[{"LOWER":"bachelor"},{"LOWER":"of"},{"IS_TITLE":True,"OP":"+"}]])
-edu_matcher.add("CERT", [[{"LOWER":"certified"},{"IS_TITLE":True,"OP":"+"}]])
+# Initialize spaCy matchers only if spaCy is available
+if nlp and is_spacy_available():
+    from spacy.matcher import PhraseMatcher, Matcher
+    
+    # ----------------------------- data lists -----------------------------
+    BASE = os.path.dirname(__file__)
+    SKILLS      = json.load(open(os.path.join(BASE, "data/skills.json")))   \
+                  if os.path.exists(os.path.join(BASE,"data/skills.json"))  \
+                  else ["python","sql","aws","selenium"]
+    JOB_TITLES  = json.load(open(os.path.join(BASE, "data/job_titles.json")))\
+                  if os.path.exists(os.path.join(BASE,"data/job_titles.json"))\
+                  else []
+
+    skill_matcher = PhraseMatcher(nlp.vocab, attr="LOWER")
+    skill_matcher.add("SKILL", [nlp.make_doc(s) for s in SKILLS])
+
+    edu_matcher = Matcher(nlp.vocab)
+    edu_matcher.add("EDU" , [[{"LOWER":"bachelor"},{"LOWER":"of"},{"IS_TITLE":True,"OP":"+"}]])
+    edu_matcher.add("CERT", [[{"LOWER":"certified"},{"IS_TITLE":True,"OP":"+"}]])
+else:
+    # Fallback: set matchers to None when spaCy is not available
+    skill_matcher = None
+    edu_matcher = None
+    SKILLS = ["python","sql","aws","selenium"]
+    JOB_TITLES = []
 
 # ----------------------------- regex helpers --------------------------
 # Jonathan's format: Company | Location | Title | Date
@@ -51,7 +62,9 @@ HEAD       = re.compile(r"^\s*(summary|skills?|technical\s+skills?|education|tra
 # ----------------------------- main -----------------------------------
 def extract_sections_spacy_fixed(text:str)->dict:
     lines = [ln.rstrip() for ln in text.splitlines()]
-    doc   = nlp(text)
+    
+    # Only create spaCy doc if nlp is available
+    doc = nlp(text) if nlp and is_spacy_available() else None
 
     # Helper function for contact detection
     def is_contact(s): return bool(re.search(r"@\w|\d{3}[-.\s]?\d{3}",s))
@@ -194,10 +207,24 @@ def extract_sections_spacy_fixed(text:str)->dict:
         out["StructuredExperiences"].append(exp)
 
     # ---------- education / training / certifications -----------------------------------
-    doc2 = nlp(text)
-    for mid, s, e in edu_matcher(doc2):
-        bucket = "Education" if nlp.vocab.strings[mid]=="EDU" else "Training"
-        out[bucket].append(doc2[s:e].text)
+    # Use spaCy matchers if available, otherwise use regex fallback
+    if doc and edu_matcher and is_spacy_available():
+        for mid, s, e in edu_matcher(doc):
+            bucket = "Education" if nlp.vocab.strings[mid]=="EDU" else "Training"
+            out[bucket].append(doc[s:e].text)
+    else:
+        # Regex fallback for education extraction
+        edu_patterns = [
+            r"(?i)\b(?:bachelor|master|phd|doctorate|associate).*(?:degree|of|in)\s+([^,\n]+)",
+            r"(?i)\b(?:bs|ba|ms|ma|mba|phd)\s+(?:in\s+)?([^,\n]+)",
+            r"(?i)\b(?:university|college|institute).*\n?.*(?:bachelor|master|phd|degree)",
+        ]
+        
+        for pattern in edu_patterns:
+            matches = re.findall(pattern, text)
+            for match in matches:
+                if isinstance(match, str) and len(match.strip()) > 3:
+                    out["Education"].append(match.strip())
     
     # Also extract certifications section manually
     cert_section_found = False

utils/reporting.py

@@ -1,4 +1,7 @@
 # utils/reporting.py
+import re
+import fitz  # PyMuPDF
+from io import BytesIO
 from config import supabase, embedding_model, client, query
 from .screening import evaluate_resumes
 

utils/screening.py

@@ -1,14 +1,14 @@
 # utils/screening.py
 from .parser     import parse_resume, extract_email, summarize_resume
 from .hybrid_extractor import extract_resume_sections
+from .spacy_loader import get_nlp, is_spacy_available
 from config      import supabase, embedding_model, client
-import spacy
 from fuzzywuzzy import fuzz
 from sentence_transformers import util
 import streamlit as st
 
-# Load spaCy model for keyword extraction
-nlp = spacy.load("en_core_web_sm")
+# Load spaCy model for keyword extraction with fallback
+nlp = get_nlp()
 from sklearn.feature_extraction.text import TfidfVectorizer
 
 def extract_keywords(text, top_n=10):
@@ -18,8 +18,17 @@ def extract_keywords(text, top_n=10):
     if not text.strip():
         return []
 
-    doc = nlp(text.lower())
-    keywords = [t.text for t in doc if t.pos_ in {"NOUN", "PROPN", "VERB", "ADJ"} and not t.is_stop]
+    # Use spaCy for keyword extraction if available, otherwise use simple word extraction
+    if nlp and is_spacy_available():
+        doc = nlp(text.lower())
+        keywords = [t.text for t in doc if t.pos_ in {"NOUN", "PROPN", "VERB", "ADJ"} and not t.is_stop]
+    else:
+        # Fallback to simple word extraction without POS tagging
+        import re
+        words = re.findall(r'\b[a-zA-Z]{3,}\b', text.lower())
+        # Filter out common stop words manually
+        stop_words = {'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had', 'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'man', 'new', 'now', 'old', 'see', 'two', 'way', 'who', 'its', 'did', 'yes', 'she', 'may', 'say', 'use', 'her', 'any', 'top', 'own', 'too', 'off', 'far', 'set', 'why', 'ask', 'men', 'run', 'end', 'put', 'lot', 'big', 'eye', 'try', 'yet', 'car', 'eat', 'job', 'sit', 'cut', 'let', 'got', 'buy', 'win', 'box', 'hit', 'add', 'oil', 'six', 'war', 'age', 'boy', 'due', 'bed', 'hot', 'cup', 'cut', 'gun', 'kid', 'red', 'sea', 'art', 'air', 'low', 'pay', 'act', 'bit', 'bad', 'law', 'dog', 'key', 'bit', 'arm', 'tax', 'gas'}
+        keywords = [word for word in words if word not in stop_words]
 
     if not keywords:
         return []

utils/spacy_loader.py

@@ -0,0 +1,67 @@
+"""
+SpaCy Model Loader with fallbacks for deployment environments
+"""
+import spacy
+import logging
+import subprocess
+import sys
+
+logger = logging.getLogger(__name__)
+
+def load_spacy_model(model_name="en_core_web_sm"):
+    """
+    Load spaCy model with fallbacks for deployment environments
+    
+    Args:
+        model_name: Name of the spaCy model to load
+        
+    Returns:
+        Loaded spaCy model or None if all attempts fail
+    """
+    
+    # Try to load the model directly first
+    try:
+        nlp = spacy.load(model_name)
+        logger.info(f"✅ Successfully loaded spaCy model: {model_name}")
+        return nlp
+    except OSError as e:
+        logger.warning(f"Failed to load {model_name} directly: {e}")
+    
+    # Try to download and install the model
+    try:
+        logger.info(f"Attempting to download {model_name}...")
+        subprocess.check_call([
+            sys.executable, "-m", "spacy", "download", model_name
+        ])
+        nlp = spacy.load(model_name)
+        logger.info(f"✅ Successfully downloaded and loaded spaCy model: {model_name}")
+        return nlp
+    except (subprocess.CalledProcessError, OSError) as e:
+        logger.warning(f"Failed to download {model_name}: {e}")
+    
+    # Try to load blank English model as fallback
+    try:
+        logger.info("Loading blank English model as fallback...")
+        nlp = spacy.blank("en")
+        logger.info("✅ Successfully loaded blank English model")
+        return nlp
+    except Exception as e:
+        logger.error(f"Failed to load blank English model: {e}")
+    
+    # Final fallback - return None
+    logger.error("❌ All spaCy model loading attempts failed")
+    return None
+
+# Global instance
+_nlp_instance = None
+
+def get_nlp():
+    """Get the global spaCy model instance"""
+    global _nlp_instance
+    if _nlp_instance is None:
+        _nlp_instance = load_spacy_model()
+    return _nlp_instance
+
+def is_spacy_available():
+    """Check if spaCy model is available"""
+    return get_nlp() is not None