Upload 19 files

README.md

@@ -1,14 +1,58 @@
 ---
-title: AI Resume Helper
-emoji: 📉
-colorFrom: gray
-colorTo: gray
-sdk: gradio
-sdk_version: 5.20.1
+title: Resume Helper
+emoji: 📄
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: 1.28.0
 app_file: app.py
 pinned: false
-license: apache-2.0
-short_description: AI powered resume analyzer/creator
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Resume Helper
+
+## Description
+
+Resume Helper is an AI-powered application that helps you tailor your resume to specific job descriptions. Using OpenAI's GPT-4o model, it analyzes your resume against job requirements, provides a match percentage, identifies gaps, and suggests improvements. You can also generate a tailored version of your resume optimized for the specific job.
+
+## Features
+
+- **Resume Analysis**: Get a detailed analysis of how well your resume matches a job description
+- **Resume Tailoring**: Generate a customized version of your resume for specific job applications
+- **Match Percentage**: See a quantitative score of how well your resume matches the job requirements
+- **Skill Breakdown**: View a detailed breakdown of your technical skills, experience, education, and soft skills
+- **Gap Identification**: Identify missing skills or experiences that are important for the job
+- **Improvement Suggestions**: Get actionable suggestions to improve your resume
+- **Template Selection**: Choose from various resume templates
+- **Verbosity Control**: Select between concise or detailed resume outputs
+- **Creativity Control**: Adjust how creative the AI should be when tailoring your resume
+- **Sample Resumes**: Use provided sample resumes to test the application
+
+## How to Use
+
+1. **API Key**: Enter your OpenAI API key in the sidebar (or use environment variables)
+2. **Upload Resume**: Upload your resume in DOCX or PDF format, or select a sample resume
+3. **Job Description**: Enter the job description you're applying for
+4. **Template (Optional)**: Select a resume template if desired
+5. **Verbosity**: Choose between "Concise" or "Elaborate" for your tailored resume
+6. **Creativity Level**: Adjust how creative the AI should be (0-100%)
+7. **Analyze**: Click "Analyze Resume" to get a detailed analysis
+8. **Tailor**: Click "Tailor Resume" to generate a customized version of your resume
+9. **Download**: Download your tailored resume in DOCX or TXT format
+
+## Limitations
+
+- The quality of analysis and tailoring depends on the quality of your resume and the job description
+- Higher creativity levels may generate content that requires verification
+- Always review AI-generated content before using it professionally
+
+## Requirements
+
+- Python 3.8+
+- OpenAI API key
+- Required Python packages (see requirements.txt)
+
+## License
+
+This project is licensed under the MIT License.

app.py

@@ -0,0 +1,691 @@
+import gradio as gr
+import os
+import tempfile
+from backend import (
+    extract_text_from_document, 
+    analyze_resume_job_match, 
+    tailor_resume, 
+    create_word_document,
+    create_tailored_resume_from_template,  
+    get_available_templates,
+    set_openai_api_key,
+    set_openai_model
+)
+import plotly.graph_objects as go
+import time as import_time
+import json
+
+# Define sample resumes
+SAMPLE_RESUMES = {
+    "Excellent Match Resume": "excellent_match_resume.docx",
+    "Good Match Resume": "good_match_resume.docx",
+    "Average Match Resume": "average_match_resume.docx",
+    "Poor Match Resume": "poor_match_resume.docx"
+}
+
+# Check if sample files exist
+for sample_name, sample_path in SAMPLE_RESUMES.items():
+    if not os.path.exists(sample_path):
+        print(f"Warning: Sample resume file not found: {sample_path}")
+
+# Read default job description
+def get_default_job_description():
+    try:
+        with open("job_desc.txt", "r") as file:
+            return file.read()
+    except:
+        return "Software Architect position requiring cloud expertise, microservices architecture, and leadership skills."
+
+# Function to get color based on percentage
+def get_color_for_percentage(percentage):
+    if percentage < 40:
+        return "#FF4B4B"  # Red for poor match
+    elif percentage < 60:
+        return "#FFA500"  # Orange for average match
+    elif percentage < 80:
+        return "#2E86C1"  # Blue for good match
+    else:
+        return "#2ECC71"  # Green for excellent match
+
+# Function to create match gauge chart
+def create_match_gauge(match_percentage):
+        if match_percentage < 40:
+            color = "#FF4B4B"  # Red
+        elif match_percentage < 60:
+            color = "#FFA500"  # Orange
+        elif match_percentage < 80:
+            color = "#2E86C1"  # Blue
+        else:
+            color = "#2ECC71"  # Green
+        
+        fig = go.Figure(go.Indicator(
+            mode="gauge+number",
+            value=match_percentage,
+            domain={'x': [0, 1], 'y': [0, 1]},
+            title={'text': "Match Percentage"},
+            gauge={
+                'axis': {'range': [0, 100], 'tickwidth': 1, 'tickcolor': "darkblue"},
+                'bar': {'color': color},
+                'bgcolor': "white",
+                'borderwidth': 2,
+                'bordercolor': "gray",
+                'steps': [
+                    {'range': [0, 40], 'color': 'rgba(255, 75, 75, 0.2)'},  # Light red
+                    {'range': [40, 60], 'color': 'rgba(255, 165, 0, 0.2)'},  # Light orange
+                    {'range': [60, 80], 'color': 'rgba(46, 134, 193, 0.2)'},  # Light blue
+                    {'range': [80, 100], 'color': 'rgba(46, 204, 113, 0.2)'}  # Light green
+                ],
+            }
+        ))
+        
+        fig.update_layout(
+            height=250,
+            margin=dict(l=20, r=20, t=50, b=20),
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)",
+            font={'color': "#444", 'family': "Arial"}
+        )
+        
+        return fig
+
+# Function to handle resume upload
+def handle_resume_upload(file):
+    if file is None:
+        return None, None
+    
+    # Save uploaded file
+    temp_dir = tempfile.mkdtemp()
+    temp_path = os.path.join(temp_dir, file.name)
+    with open(temp_path, "wb") as f:
+        f.write(file)
+    
+    # Extract text
+    resume_text = extract_text_from_document(temp_path)
+    template_path = temp_path if temp_path.endswith('.docx') else None
+    
+    return resume_text, template_path
+
+# Function to handle sample resume selection
+def handle_sample_resume(sample_name):
+    if not sample_name:
+        return None, None
+    
+    resume_path = SAMPLE_RESUMES[sample_name]
+    if os.path.exists(resume_path):
+        # Extract text
+        resume_text = extract_text_from_document(resume_path)
+        template_path = resume_path
+        return resume_text, template_path
+    else:
+        print(f"Sample resume file not found: {resume_path}")
+        return None, None
+
+# Function to handle template selection
+def handle_template_selection(use_template, selected_template):
+    if use_template and selected_template != "None":
+        return selected_template
+    return None
+
+# Function to analyze resume
+def analyze_resume(resume_text, job_description, creativity_level):
+    if not resume_text or not job_description:
+        return None, "Please provide both a resume and job description."
+    
+    try:
+        analysis_results = analyze_resume_job_match(
+            resume_text,
+            job_description,
+            creativity_level
+        )
+        
+        # Create the match gauge chart
+        match_percentage = analysis_results.get("match_percentage", 0)
+        gauge_chart = create_match_gauge(match_percentage)
+        
+        # Determine match category and description
+        if match_percentage < 40:
+            match_category = "Poor Match"
+            match_description = "Your resume needs significant improvements to match this job description."
+        elif match_percentage < 60:
+            match_category = "Average Match"
+            match_description = "Your resume partially matches the job description but could use improvements."
+        elif match_percentage < 80:
+            match_category = "Good Match"
+            match_description = "Your resume matches well with the job description with some room for improvement."
+        else:
+            match_category = "Excellent Match"
+            match_description = "Your resume is very well aligned with the job description!"
+        
+        # Format the analysis results for display
+        formatted_results = f"## Match Analysis\n\n"
+        formatted_results += f"**Match Category:** {match_category}\n\n"
+        formatted_results += f"**Match Description:** {match_description}\n\n"
+        
+        # Add skill breakdown
+        if "skill_breakdown" in analysis_results:
+            formatted_results += "## Skill Breakdown\n\n"
+            skill_breakdown = analysis_results["skill_breakdown"]
+            
+            for skill_type, skill_data in skill_breakdown.items():
+                formatted_results += f"### {skill_type.replace('_', ' ').title()}\n"
+                formatted_results += f"**Percentage:** {skill_data.get('percentage', 0)}%\n"
+                formatted_results += f"**Comments:** {skill_data.get('comments', '')}\n\n"
+        
+        # Add key matches
+        if "key_matches" in analysis_results:
+            formatted_results += "## Key Matches\n\n"
+            for match in analysis_results["key_matches"]:
+                formatted_results += f"- {match}\n"
+            formatted_results += "\n"
+        
+        # Add gaps
+        if "gaps" in analysis_results:
+            formatted_results += "## Gaps Identified\n\n"
+            for gap in analysis_results["gaps"]:
+                formatted_results += f"- {gap}\n"
+            formatted_results += "\n"
+        
+        # Add suggestions
+        if "suggestions" in analysis_results:
+            formatted_results += "## Improvement Suggestions\n\n"
+            for suggestion in analysis_results["suggestions"]:
+                formatted_results += f"- {suggestion}\n"
+            formatted_results += "\n"
+        
+        # Add summary
+        if "summary" in analysis_results:
+            formatted_results += "## Summary\n\n"
+            formatted_results += analysis_results["summary"]
+        
+        return analysis_results, formatted_results
+    except Exception as e:
+        return None, f"Error analyzing resume: {str(e)}"
+
+# Function to tailor resume
+def tailor_resume_func(resume_text, job_description, template_path, creativity_level, verbosity):
+    if not resume_text or not job_description:
+        return None, "Please provide both a resume and job description."
+    
+    try:
+        tailored_resume = tailor_resume(
+            resume_text,
+            job_description,
+            template_path,
+            creativity_level,
+            verbosity
+        )
+        
+        return tailored_resume, "Resume tailored successfully!"
+    except Exception as e:
+        return None, f"Error tailoring resume: {str(e)}"
+
+# Function to create and download Word document
+def create_word_doc(tailored_resume, template_path):
+    if not tailored_resume:
+        return None, "No tailored resume to download."
+    
+    try:
+        # Create a temporary file
+        temp_dir = tempfile.mkdtemp()
+        output_path = os.path.join(temp_dir, "tailored_resume.docx")
+        
+        # Create Word document
+        if template_path and os.path.exists(template_path):
+            success = create_tailored_resume_from_template(
+                tailored_resume,
+                template_path,
+                output_path
+            )
+        else:
+            success = create_word_document(
+                tailored_resume,
+                output_path
+            )
+        
+        if success:
+            return output_path, "DOCX file created successfully!"
+        else:
+            return None, "Failed to create DOCX file."
+    except Exception as e:
+        return None, f"Error creating DOCX file: {str(e)}"
+
+# Function to update API key
+def update_api_key(api_key):
+    if not api_key:
+        return "Using API key from environment variables if available."
+    
+    api_configured = set_openai_api_key(api_key)
+    if api_configured:
+        return "✅ API key configured successfully!"
+    else:
+        return "❌ Failed to configure API key."
+
+# Function to update model
+def update_model(model):
+    set_openai_model(model)
+    return f"✅ Model set to {model}"
+
+# Main function to create the Gradio interface
+def create_interface():
+    print("Creating interface...")
+    # Define the blocks with custom theme
+    with gr.Blocks(title="Resume Helper", theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="indigo",
+        font=[gr.themes.GoogleFont("Poppins"), "ui-sans-serif", "system-ui", "sans-serif"],
+    )) as app:
+        gr.Markdown("# 📄 Resume Helper")
+        gr.Markdown("Upload your resume and get AI-powered analysis and tailoring to match job descriptions.")
+        
+        # State variables
+        resume_text = gr.State(None)
+        template_path = gr.State(None)
+        analysis_results = gr.State(None)
+        tailored_resume_text = gr.State(None)
+        
+        with gr.Row():
+            # Left column - Inputs
+            with gr.Column(scale=1):
+                # Configuration section
+                with gr.Accordion("⚙️ Configuration", open=False):
+                    api_key = gr.Textbox(
+                        label="OpenAI API Key",
+                        placeholder="Enter your OpenAI API key (optional)",
+                        type="password"
+                    )
+                    api_status = gr.Markdown("Using API key from environment variables if available.")
+                    api_key.change(update_api_key, inputs=[api_key], outputs=[api_status])
+                    
+                    model_options = ["gpt-4o-mini", "gpt-4o"]
+                    model_selector = gr.Dropdown(
+                        label="Select AI Model",
+                        choices=model_options,
+                        value="gpt-4o-mini",
+                        info="Choose the OpenAI model to use. GPT-4o-mini is faster and cheaper, while GPT-4o provides more detailed analysis."
+                    )
+                    model_status = gr.Markdown("")
+                    model_selector.change(update_model, inputs=[model_selector], outputs=[model_status])
+                
+                # Resume upload section
+                gr.Markdown("### 📤 Upload Your Resume")
+                resume_option = gr.Radio(
+                    label="Choose an option:",
+                    choices=["Upload my resume", "Use a sample resume"],
+                    value="Upload my resume"
+                )
+                
+                # Upload resume file
+                upload_file = gr.File(
+                    label="Upload your resume (DOCX, PDF)",
+                    file_types=[".docx", ".pdf"],
+                    visible=True
+                )
+                
+                # Sample resume selection
+                sample_resume = gr.Dropdown(
+                    label="Select a sample resume:",
+                    choices=list(SAMPLE_RESUMES.keys()),
+                    visible=False
+                )
+                
+                # Show/hide based on selection
+                def update_resume_option(option):
+                    return {
+                        upload_file: gr.update(visible=option == "Upload my resume"),
+                        sample_resume: gr.update(visible=option == "Use a sample resume")
+                    }
+                
+                resume_option.change(update_resume_option, inputs=[resume_option], outputs=[upload_file, sample_resume])
+                
+                # Template selection
+                gr.Markdown("### 📄 Select Resume Template (Optional)")
+                templates = get_available_templates()
+                print(f"Templates: {templates}")
+                use_template = gr.Checkbox(label="Use a resume template", value=False)
+                template_selector = gr.Dropdown(
+                    label="Choose a template:",
+                    choices=["None"] + templates,
+                    value="None",
+                    visible=False
+                )
+                print(f"Template selector: ")
+
+                def update_template_visibility(use_template):
+                    return gr.update(visible=use_template)
+                
+                use_template.change(update_template_visibility, inputs=[use_template], outputs=[template_selector])
+                
+                # Job description
+                gr.Markdown("### 📋 Job Description")
+                job_description = gr.Textbox(
+                    label="Job Description",
+                    value=get_default_job_description(),
+                    lines=10
+                )
+                
+                # MOVED FROM RIGHT COLUMN: Resume detail level
+                gr.Markdown("### 📝 Resume Detail Level")
+                verbosity = gr.Radio(
+                    label="Choose how detailed your tailored resume should be:",
+                    choices=["Concise", "Elaborate"],
+                    value="Elaborate"
+                )
+                
+                # MOVED FROM RIGHT COLUMN: Creativity level
+                gr.Markdown("### 🎨 Creativity Level")
+                creativity_level = gr.Slider(
+                    label="Adjust how creative the AI should be when tailoring your resume",
+                    minimum=0,
+                    maximum=100,
+                    value=30,
+                    step=10,
+                    info="Higher values mean more creative modifications to your resume"
+                )
+                
+                creativity_warning = gr.Markdown(visible=False)
+                
+                def update_creativity_warning(level):
+                    if level > 70:
+                        return gr.update(visible=True, value="⚠️ High creativity levels may generate content that significantly modifies your original resume. Review carefully before using.")
+                    else:
+                        return gr.update(visible=False)
+                
+                creativity_level.change(update_creativity_warning, inputs=[creativity_level], outputs=[creativity_warning])
+                
+                # MOVED FROM RIGHT COLUMN: Action buttons
+                gr.Markdown("### 🚀 Actions")
+                with gr.Row():
+                    analyze_btn = gr.Button("🔍 Analyze Resume", variant="primary")
+                    tailor_btn = gr.Button("✏️ Tailor Resume", variant="primary")
+                    reset_btn = gr.Button("🔄 Reset All", variant="secondary")
+                
+                # Add loading indicator below the buttons
+                loading_indicator = gr.Markdown(visible=False)
+            
+            # Right column - Results
+            with gr.Column(scale=1):
+                # Results section - Now directly in the right column, not in an accordion
+                with gr.Tabs() as results_tabs:
+                    # Analysis tab
+                    with gr.TabItem("📊 Analysis"):
+                        analysis_plot = gr.Plot(label="Match Percentage")
+                        analysis_output = gr.Markdown()
+                    
+                    # Tailored Resume tab
+                    with gr.TabItem("📝 Tailored Resume"):
+                        tailored_resume = gr.Textbox(label="Tailored Resume", lines=15)
+                        
+                        # Create download buttons but initially hide them
+                        with gr.Row():
+                            download_docx = gr.Button("📄 Download as DOCX", variant="primary", visible=False)
+                            download_txt = gr.Button("📝 Download as TXT", variant="primary", visible=False)
+                        
+                        # Create file components but initially hide them
+                        docx_file = gr.File(label="Download DOCX", visible=False)
+                        txt_file = gr.File(label="Download TXT", visible=False)
+                        
+                        download_status = gr.Markdown()
+
+        # Event handlers
+        def process_resume_input(resume_opt, upload_file, sample_name, use_template_opt, template_selection):
+            if resume_opt == "Upload my resume" and upload_file is not None:
+                resume_text, template_path = handle_resume_upload(upload_file)
+            elif resume_opt == "Use a sample resume" and sample_name:
+                resume_text, template_path = handle_sample_resume(sample_name)
+            else:
+                resume_text, template_path = None, None
+            
+            if use_template_opt and template_selection != "None":
+                template_path = template_selection
+            
+            return resume_text, template_path
+        
+        # Handle file upload
+        upload_file.upload(
+            lambda file: process_resume_input("Upload my resume", file, None, use_template.value, template_selector.value),
+            inputs=[upload_file],
+            outputs=[resume_text, template_path]
+        )
+        
+        # Handle sample selection
+        sample_resume.change(
+            lambda sample: process_resume_input("Use a sample resume", None, sample, use_template.value, template_selector.value),
+            inputs=[sample_resume],
+            outputs=[resume_text, template_path]
+        )
+        
+        # Handle template selection
+        template_selector.change(
+            lambda template, resume_txt, current_template: (resume_txt, template if template != "None" else current_template),
+            inputs=[template_selector, resume_text, template_path],
+            outputs=[resume_text, template_path]
+        )
+        
+        # Analyze button handler with loading indicator
+        def analyze_with_loading(resume_txt, job_desc, creativity):
+            if not resume_txt:
+                return (
+                    gr.update(visible=False), 
+                    None, 
+                    gr.update(visible=False), 
+                    "", 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True)
+                )
+            
+            # Show loading message and disable buttons
+            yield (
+                gr.update(visible=True, value="⏳ Analyzing your resume... This may take a moment."), 
+                None, 
+                gr.update(visible=False), 
+                "", 
+                gr.update(interactive=False), 
+                gr.update(interactive=False), 
+                gr.update(interactive=False)
+            )
+            
+            # Perform the actual analysis
+            results, formatted_output = analyze_resume(resume_txt, job_desc, creativity)
+            
+            # Hide loading, show results, and re-enable buttons
+            if results:
+                match_percentage = results.get("match_percentage", 0)
+                gauge_chart = create_match_gauge(match_percentage)
+                yield (
+                    gr.update(visible=False), 
+                    results, 
+                    gauge_chart, 
+                    formatted_output, 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True)
+                )
+            else:
+                yield (
+                    gr.update(visible=False), 
+                    None, 
+                    gr.update(visible=False), 
+                    formatted_output, 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True)
+                )
+        
+        analyze_btn.click(
+            analyze_with_loading,
+            inputs=[resume_text, job_description, creativity_level],
+            outputs=[
+                loading_indicator, 
+                analysis_results, 
+                analysis_plot, 
+                analysis_output, 
+                analyze_btn, 
+                tailor_btn, 
+                reset_btn
+            ],
+            queue=True
+        )
+        
+        # Tailor button handler with loading indicator
+        def tailor_with_loading(resume_txt, job_desc, template, creativity, verbosity_level):
+            if not resume_txt:
+                return (
+                    gr.update(visible=False), 
+                    None, 
+                    "", 
+                    gr.update(visible=False), 
+                    gr.update(visible=False), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True)
+                )
+            
+            # Show loading message and disable buttons
+            yield (
+                gr.update(visible=True, value="⏳ Tailoring your resume... This may take a moment."), 
+                None, 
+                "", 
+                gr.update(visible=False), 
+                gr.update(visible=False), 
+                gr.update(interactive=False), 
+                gr.update(interactive=False), 
+                gr.update(interactive=False)
+            )
+            
+            # Perform the actual tailoring
+            tailored, message = tailor_resume_func(
+                resume_txt, 
+                job_desc, 
+                template, 
+                creativity, 
+                verbosity_level.lower()
+            )
+            
+            # Hide loading, show results, and re-enable buttons
+            if tailored:
+                # Show download buttons only when tailored resume is created
+                yield (
+                    gr.update(visible=False), 
+                    tailored, 
+                    tailored, 
+                    gr.update(visible=True), 
+                    gr.update(visible=True), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True)
+                )
+            else:
+                # Hide download buttons if tailoring fails
+                yield (
+                    gr.update(visible=False), 
+                    None, 
+                    message, 
+                    gr.update(visible=False), 
+                    gr.update(visible=False), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True), 
+                    gr.update(interactive=True)
+                )
+        
+        tailor_btn.click(
+            tailor_with_loading,
+            inputs=[resume_text, job_description, template_path, creativity_level, verbosity],
+            outputs=[
+                loading_indicator, 
+                tailored_resume_text, 
+                tailored_resume, 
+                download_docx, 
+                download_txt, 
+                analyze_btn, 
+                tailor_btn, 
+                reset_btn
+            ],
+            queue=True
+        )
+        
+        # Download handlers
+        def create_docx_handler(tailored_txt, template):
+            if not tailored_txt:
+                return gr.update(visible=False), "No tailored resume to download."
+            
+            file_path, message = create_word_doc(tailored_txt, template)
+            if file_path:
+                return gr.update(visible=True, value=file_path), message
+            else:
+                return gr.update(visible=False), message
+        
+        download_docx.click(
+            create_docx_handler,
+            inputs=[tailored_resume_text, template_path],
+            outputs=[docx_file, download_status]
+        )
+        
+        # Download as TXT
+        def download_txt_handler(tailored_txt):
+            if not tailored_txt:
+                return gr.update(visible=False), "No tailored resume to download."
+            
+            # Create a temporary file
+            temp_dir = tempfile.mkdtemp()
+            output_path = os.path.join(temp_dir, "tailored_resume.txt")
+            
+            with open(output_path, "w") as f:
+                f.write(tailored_txt)
+            
+            return gr.update(visible=True, value=output_path), "TXT file created successfully!"
+        
+        download_txt.click(
+            download_txt_handler,
+            inputs=[tailored_resume_text],
+            outputs=[txt_file, download_status]
+        )
+        
+        # Reset handler
+        def reset_all():
+            return (
+                None, None, None, None,
+                gr.update(value=None), 
+                gr.update(value="Upload my resume"),
+                gr.update(value=None),
+                gr.update(value=None),
+                gr.update(value="None"),
+                gr.update(value=get_default_job_description()),
+                gr.update(value="Elaborate"),
+                gr.update(value=30),
+                gr.update(visible=False),
+                gr.update(value=""),
+                gr.update(value=""),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False)
+            )
+        
+        reset_btn.click(
+            reset_all,
+            inputs=[],
+            outputs=[
+                resume_text, template_path, analysis_results, tailored_resume_text,
+                upload_file, resume_option, sample_resume, use_template, template_selector,
+                job_description, verbosity, creativity_level, creativity_warning,
+                analysis_output, tailored_resume,
+                download_docx, download_txt, docx_file, txt_file
+            ]
+        )
+
+# Footer
+        gr.Markdown("---")
+        gr.Markdown("### 📝 Disclaimer")
+        gr.Markdown("""
+This tool uses AI to analyze and tailor resumes. While it strives for accuracy, please review all generated content before using it professionally.
+Higher creativity levels may generate content that requires more thorough verification. Always ensure that your resume accurately represents your skills and experience.
+""")
+    print("Interface created successfully")
+    return app
+
+# Launch the app
+if __name__ == "__main__":
+    app = create_interface()
+    app.queue()  # Enable the queue for the app
+    app.launch()

average_match_resume.docx.txt

@@ -0,0 +1,50 @@
+DAVID CHEN
+Software Developer
+[email protected] | (555) 456-7890 | linkedin.com/in/davidchen
+Boston, MA | Remote Available
+
+PROFESSIONAL SUMMARY
+Software Developer with 6 years of experience building web applications and services. Experienced in full-stack development with a focus on backend systems and API development. Seeking to leverage my technical skills in a software architecture role.
+
+SKILLS
+• Programming: Java, JavaScript, TypeScript, Node.js
+• Web Technologies: React, Angular, HTML, CSS
+• Databases: MySQL, PostgreSQL, MongoDB
+• Cloud: Basic AWS (EC2, S3)
+• Tools: Git, JIRA, VS Code
+• Testing: Jest, JUnit, Selenium
+• Methodologies: Agile, Scrum
+
+PROFESSIONAL EXPERIENCE
+
+SENIOR SOFTWARE DEVELOPER | WebTech Solutions | 2019 - Present
+• Develop and maintain full-stack web applications using React, Node.js, and PostgreSQL
+• Design and implement RESTful APIs for internal and external service integration
+• Collaborate with product managers to understand business requirements
+• Participate in code reviews and provide feedback to team members
+• Implement automated testing using Jest and Selenium
+• Deploy applications to AWS using EC2 and S3
+• Mentor junior developers on coding standards and best practices
+
+SOFTWARE DEVELOPER | Digital Creations | 2016 - 2019
+• Developed front-end interfaces using Angular and TypeScript
+• Created and maintained backend services using Java Spring Boot
+• Implemented database schemas and queries in MySQL
+• Participated in agile development processes, including daily stand-ups and sprint planning
+• Collaborated with UX designers to implement user interfaces
+• Fixed bugs and improved application performance
+• Documented code and created technical specifications
+
+JUNIOR DEVELOPER | Tech Startups Inc. | 2015 - 2016
+• Assisted in the development of web applications using JavaScript and PHP
+• Created responsive web designs using HTML and CSS
+• Fixed bugs and implemented minor features
+• Participated in code reviews and team meetings
+• Learned and applied new technologies and frameworks
+
+EDUCATION
+• Bachelor of Science in Computer Science, Boston University, 2015
+
+CERTIFICATIONS
+• Oracle Certified Professional, Java SE 8 Programmer
+• MongoDB Certified Developer 

backend.py

@@ -0,0 +1,819 @@
+import os
+import docx2txt
+import docx
+from docx import Document
+import openai
+from dotenv import load_dotenv
+import json
+import tempfile
+import re
+
+# Add these imports for PDF support
+import PyPDF2
+import io
+
+# Load environment variables
+load_dotenv()
+
+# Set up OpenAI API key
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+# Default model
+DEFAULT_MODEL = "gpt-4o"
+current_model = DEFAULT_MODEL
+
+# Function to set OpenAI API key
+def set_openai_api_key(api_key=None):
+    """
+    Set the OpenAI API key from the provided key or environment variable.
+    
+    Args:
+        api_key: Optional API key to use. If None, will use the environment variable.
+        
+    Returns:
+        bool: True if API key is set, False otherwise
+    """
+    if api_key:
+        openai.api_key = api_key
+        return True
+    else:
+        env_api_key = os.getenv("OPENAI_API_KEY")
+        if env_api_key:
+            openai.api_key = env_api_key
+            return True
+        return False
+
+# Function to set OpenAI model
+def set_openai_model(model_name="gpt-4o"):
+    """
+    Set the OpenAI model to use for API calls.
+    
+    Args:
+        model_name: Name of the model to use (e.g., "gpt-4o", "gpt-4o-mini")
+        
+    Returns:
+        str: The name of the model that was set
+    """
+    global current_model
+    current_model = model_name
+    return current_model
+
+# Set up OpenAI API key from environment variable initially
+set_openai_api_key()
+
+def extract_text_from_document(file_path):
+    """
+    Extract text from a document file (DOCX or PDF).
+    
+    Args:
+        file_path: Path to the document file
+        
+    Returns:
+        str: Extracted text from the document
+    """
+    try:
+        # Check file extension
+        if file_path.lower().endswith('.docx'):
+            # Extract text from DOCX
+            return docx2txt.process(file_path)
+        elif file_path.lower().endswith('.pdf'):
+            # Extract text from PDF
+            text = ""
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                for page_num in range(len(pdf_reader.pages)):
+                    page = pdf_reader.pages[page_num]
+                    text += page.extract_text() + "\n\n"
+            return text
+        else:
+            raise ValueError(f"Unsupported file format: {os.path.splitext(file_path)[1]}")
+    except Exception as e:
+        print(f"Error extracting text from document: {e}")
+        return None
+
+def parse_resume(file_path):
+    """
+    Parse a resume file and extract its content.
+    
+    Args:
+        file_path: Path to the resume file
+        
+    Returns:
+        str: Extracted text from the resume
+    """
+    try:
+        return extract_text_from_document(file_path)
+    except Exception as e:
+        print(f"Error parsing resume: {e}")
+        return None
+
+def analyze_resume_job_match(resume_text, job_description, creativity_level=30):
+    """
+    Analyze the match between a resume and job description using GPT-4o.
+    
+    Args:
+        resume_text: Raw text of the resume
+        job_description: Job description text
+        creativity_level: Level of creativity/modification allowed (0-100)
+        
+    Returns:
+        dict: Analysis results including match percentage, gaps, and suggestions
+    """
+    try:
+        print(f"Analyzing resume match with creativity level: {creativity_level}")
+        print(f"Resume text length: {len(resume_text)}")
+        print(f"Job description length: {len(job_description)}")
+        
+        # Adjust system message based on creativity level
+        if creativity_level < 20:
+            system_message = "You are a conservative resume analyzer. Focus only on exact matches between the resume and job description. Be strict in your evaluation."
+        elif creativity_level < 50:
+            system_message = "You are a balanced resume analyzer. Evaluate the resume against the job description with a moderate level of flexibility, recognizing transferable skills."
+        elif creativity_level < 80:
+            system_message = "You are a creative resume analyzer. Be generous in your evaluation, recognizing potential and transferable skills even when not explicitly stated."
+        else:
+            system_message = "You are an optimistic resume analyzer. Focus on potential rather than exact matches. Be very generous in your evaluation and provide ambitious suggestions for improvement."
+        
+        prompt = f"""
+        Analyze the following resume and job description:
+        
+        RESUME:
+        {resume_text}
+        
+        JOB DESCRIPTION:
+        {job_description}
+        
+        CREATIVITY LEVEL: {creativity_level}% (where 0% means strictly factual and 100% means highly creative)
+        
+        Provide a detailed analysis in JSON format with the following structure:
+        1. "match_percentage": A numerical percentage (0-100) representing how well the resume matches the job description. Use job skills keyword used in job description to match with the contents of the resume to come up with the match percentage.
+        2. "key_matches": List of skills and experiences in the resume that match the job requirements.
+        3. "gaps": List of skills or experiences mentioned in the job description that are missing from the resume.
+        4. "suggestions": Specific suggestions to improve the resume for this job. Ensure the suggestions are based on the job description and the resume and contain the exact keywords from the job description.
+        5. "summary": A brief summary of the overall match and main recommendations.
+        6. "skill_breakdown": An object containing categories of skills from the job description and how well the candidate matches each category:
+           - "technical_skills": Assessment of technical skills match (percentage and comments)
+           - "experience": Assessment of experience requirements match (percentage and comments)
+           - "education": Assessment of education requirements match (percentage and comments)
+           - "soft_skills": Assessment of soft skills/leadership match (percentage and comments)
+        
+        Adjust your analysis based on the creativity level. Higher creativity means being more generous with matches and more ambitious with suggestions.
+        
+        IMPORTANT: For each resume, provide a unique and accurate match percentage based on the actual content. Do not use the same percentage for different resumes. The excellent match resume should have a high percentage (80-95%), good match should be moderate-high (65-80%), average match should be moderate (40-65%), and poor match should be low (below 40%).
+        
+        Return ONLY the JSON object without any additional text.
+        """
+        
+        response = openai.chat.completions.create(
+            model=current_model,
+            messages=[
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": prompt}
+            ],
+            response_format={"type": "json_object"}
+        )
+        
+        analysis = json.loads(response.choices[0].message.content)
+        print(f"Analysis complete. Match percentage: {analysis.get('match_percentage', 0)}%")
+        return analysis
+    
+    except Exception as e:
+        print(f"Error analyzing resume: {e}")
+        return {
+            "match_percentage": 0,
+            "key_matches": [],
+            "gaps": ["Error analyzing resume"],
+            "suggestions": ["Please try again"],
+            "summary": f"Error: {str(e)}",
+            "skill_breakdown": {
+                "technical_skills": {"percentage": 0, "comments": "Error analyzing resume"},
+                "experience": {"percentage": 0, "comments": "Error analyzing resume"},
+                "education": {"percentage": 0, "comments": "Error analyzing resume"},
+                "soft_skills": {"percentage": 0, "comments": "Error analyzing resume"}
+            }
+        }
+
+def tailor_resume(resume_text, job_description, template_path=None, creativity_level=30, verbosity="elaborate"):
+    """
+    Generate a tailored resume based on the job description using GPT-4o.
+    
+    Args:
+        resume_text: Raw text of the original resume
+        job_description: Job description text
+        template_path: Optional path to a resume template
+        creativity_level: Level of creativity/modification allowed (0-100)
+        verbosity: Level of detail in the resume ('concise' or 'elaborate')
+        
+    Returns:
+        str: Tailored resume content
+    """
+    try:
+        # If a template is provided, read its structure
+        template_structure = ""
+        template_sections = []
+        
+        if template_path:
+            # Extract the template structure and sections
+            doc = Document(template_path)
+            for para in doc.paragraphs:
+                if para.text.strip():
+                    template_structure += para.text + "\n"
+                    # Identify section headings (usually in all caps or with specific styles)
+                    if para.style.name.startswith('Heading') or para.text.isupper() or (para.runs and para.runs[0].bold):
+                        template_sections.append(para.text.strip())
+        
+        # Adjust system message based on creativity level
+        if creativity_level < 20:
+            system_message = "You are a conservative resume editor. Only reorganize existing content to better match the job description. Do not add any new experiences or skills that aren't explicitly mentioned in the original resume."
+        elif creativity_level < 50:
+            system_message = "You are a balanced resume editor. Enhance existing content with better wording and highlight relevant skills. Make minor improvements but keep all content factual and based on the original resume."
+        elif creativity_level < 80:
+            system_message = "You are a creative resume editor. Significantly enhance the resume with improved wording and may suggest minor additions or extensions of existing experiences to better match the job description."
+        else:
+            system_message = "You are an aggressive resume optimizer. Optimize the resume to perfectly match the job description, including suggesting new skills and experiences that would make the candidate more competitive, while maintaining some connection to their actual background. Ensure exact keywords are included from the job description in the new resume. "
+            
+        # Adjust system message based on creativity level and verbosity
+        if creativity_level < 20:
+            base_message = "You are a conservative resume editor. Only reorganize existing content to better match the job description. Do not add any new experiences or skills that aren't explicitly mentioned in the original resume."
+        elif creativity_level < 50:
+            base_message = "You are a balanced resume editor. Enhance existing content with better wording and highlight relevant skills. Make minor improvements but keep all content factual and based on the original resume."
+        elif creativity_level < 80:
+            base_message = "You are a creative resume editor. Significantly enhance the resume with improved wording and may suggest minor additions or extensions of existing experiences to better match the job description."
+        else:
+            base_message = "You are an aggressive resume optimizer. Optimize the resume to perfectly match the job description, including suggesting new skills and experiences that would make the candidate more competitive, while maintaining some connection to their actual background. Ensure exact keywords are included from the job description in the new resume."
+        
+        # Add verbosity instructions to the system message
+        if verbosity == "concise":
+            system_message = base_message + " Create a concise resume with brief bullet points, focusing only on the most relevant information. Aim for a shorter resume that can be quickly scanned by recruiters."
+        else:  # elaborate
+            system_message = base_message + " Create a detailed resume that thoroughly explains experiences and skills, providing context and specific achievements. Use comprehensive bullet points to showcase the candidate's qualifications."
+        
+        prompt = f"""
+        Create a tailored version of this resume to better match the job description:
+        
+        ORIGINAL RESUME:
+        {resume_text}
+        
+        JOB DESCRIPTION:
+        {job_description}
+        
+        {("TEMPLATE STRUCTURE TO FOLLOW:" + chr(10) + template_structure) if template_path else ""}
+        
+        {("TEMPLATE SECTIONS TO INCLUDE:" + chr(10) + chr(10).join(template_sections)) if template_sections else ""}
+        
+        CREATIVITY LEVEL: {creativity_level}% (where 0% means strictly factual and 100% means highly creative)
+        VERBOSITY: {verbosity.upper()} (CONCISE means brief and to-the-point, ELABORATE means detailed and comprehensive)
+        
+        Create a tailored resume that:
+        1. Highlights relevant skills and experiences that match the job description
+        2. Uses keywords from the job description
+        3. Quantifies achievements where possible
+        4. Removes or downplays irrelevant information
+        5. Adjusts content based on the specified creativity level
+        
+        IMPORTANT FORMATTING INSTRUCTIONS:
+        - Format your response with clear section headings in ALL CAPS
+        - Use bullet points (•) for listing items and achievements
+        - If a template is provided, follow its exact section structure and organization
+        - Maintain the same section headings as in the template when possible
+        - For each section, provide content that matches the requested verbosity level:
+          * CONCISE: Use 1-2 line bullet points, focus only on the most relevant achievements
+          * ELABORATE: Use detailed bullet points with context and specific metrics
+        
+        Return the complete tailored resume content in a professional format.
+        """
+        
+        response = openai.chat.completions.create(
+            model=current_model,
+            messages=[
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": prompt}
+            ]
+        )
+        
+        tailored_resume = response.choices[0].message.content
+        return tailored_resume
+    
+    except Exception as e:
+        print(f"Error tailoring resume: {e}")
+        return f"Error tailoring resume: {str(e)}"
+
+def create_word_document(content, output_path, template_path=None):
+    """
+    Create a Word document with the given content, optionally using a template.
+    
+    Args:
+        content: Text content for the document
+        output_path: Path to save the document
+        template_path: Optional path to a template document to use as a base
+        
+    Returns:
+        bool: Success status
+    """
+    try:
+        # If a template is provided, use it as the base document
+        if template_path and os.path.exists(template_path):
+            # Create a new document instead of modifying the template directly
+            doc = Document()
+            original_template = Document(template_path)
+            
+            # Copy all styles from the template to the new document
+            for style in original_template.styles:
+                if style.name not in doc.styles:
+                    try:
+                        doc.styles.add_style(style.name, style.type)
+                    except:
+                        pass  # Style might already exist or be built-in
+            
+            # Copy document properties and sections settings
+            # We'll only add sections as needed, not at the beginning
+            if len(original_template.sections) > 0:
+                # Copy properties from the first section
+                section = original_template.sections[0]
+                # Use the existing first section in the new document
+                new_section = doc.sections[0]
+                new_section.page_height = section.page_height
+                new_section.page_width = section.page_width
+                new_section.left_margin = section.left_margin
+                new_section.right_margin = section.right_margin
+                new_section.top_margin = section.top_margin
+                new_section.bottom_margin = section.bottom_margin
+                new_section.header_distance = section.header_distance
+                new_section.footer_distance = section.footer_distance
+                
+                # Copy additional sections if needed
+                for i in range(1, len(original_template.sections)):
+                    section = original_template.sections[i]
+                    new_section = doc.add_section()
+                    new_section.page_height = section.page_height
+                    new_section.page_width = section.page_width
+                    new_section.left_margin = section.left_margin
+                    new_section.right_margin = section.right_margin
+                    new_section.top_margin = section.top_margin
+                    new_section.bottom_margin = section.bottom_margin
+                    new_section.header_distance = section.header_distance
+                    new_section.footer_distance = section.footer_distance
+            
+            # Copy complex elements like headers and footers
+            copy_template_complex_elements(original_template, doc)
+            
+            # Split content by sections (using headings as delimiters)
+            sections = []
+            current_section = []
+            lines = content.split('\n')
+            
+            for line in lines:
+                line = line.strip()
+                if not line:
+                    continue
+                    
+                # Check if this is a heading (all caps or ends with a colon)
+                if line.isupper() or (line.endswith(':') and len(line) < 50):
+                    if current_section:
+                        sections.append(current_section)
+                    current_section = [line]
+                else:
+                    current_section.append(line)
+            
+            if current_section:
+                sections.append(current_section)
+            
+            # Find template headings to match with our content sections
+            template_headings = []
+            template_heading_styles = {}
+            for para in original_template.paragraphs:
+                if para.style.name.startswith('Heading') or para.text.isupper() or (para.runs and para.runs[0].bold):
+                    template_headings.append(para.text.strip())
+                    template_heading_styles[para.text.strip()] = para.style.name
+            
+            # Add content to the document with appropriate formatting
+            for section in sections:
+                if not section:
+                    continue
+                    
+                # First line of each section is treated as a heading
+                heading = section[0]
+                
+                # Try to find a matching heading style from the template
+                heading_style = 'Heading 1'  # Default
+                for template_heading in template_headings:
+                    if template_heading.upper() == heading.upper() or template_heading.upper() in heading.upper() or heading.upper() in template_heading.upper():
+                        heading_style = template_heading_styles.get(template_heading, 'Heading 1')
+                        break
+                
+                # Add the heading with the appropriate style
+                p = doc.add_paragraph()
+                try:
+                    p.style = heading_style
+                except:
+                    p.style = 'Heading 1'  # Fallback
+                
+                run = p.add_run(heading)
+                run.bold = True
+                
+                # Add the rest of the section content
+                for line in section[1:]:
+                    if line.startswith('•') or line.startswith('-') or line.startswith('*'):
+                        # This is a bullet point
+                        p = doc.add_paragraph(line[1:].strip(), style='List Bullet')
+                    else:
+                        p = doc.add_paragraph(line)
+        else:
+            # Create a new document with basic formatting
+            doc = Document()
+            
+            # Split content by lines and add to document with basic formatting
+            paragraphs = content.split('\n')
+            for para in paragraphs:
+                para = para.strip()
+                if not para:
+                    continue
+                    
+                # Check if this is a heading (all caps or ends with a colon)
+                if para.isupper() or (para.endswith(':') and len(para) < 50):
+                    p = doc.add_paragraph()
+                    p.style = 'Heading 1'
+                    run = p.add_run(para)
+                    run.bold = True
+                elif para.startswith('•') or para.startswith('-') or para.startswith('*'):
+                    # This is a bullet point
+                    p = doc.add_paragraph(para[1:].strip(), style='List Bullet')
+                else:
+                    doc.add_paragraph(para)
+        
+        doc.save(output_path)
+        return True
+    
+    except Exception as e:
+        print(f"Error creating Word document: {e}")
+        return False
+
+def get_available_templates():
+    """
+    Get a list of available resume templates from the current working directory.
+    
+    Returns:
+        list: List of template file paths
+    """
+    # First, copy any templates from templates directory if they don't exist
+    #copy_templates_to_current_directory()
+    
+    templates = []
+    
+    # Check current directory for templates
+    for file in os.listdir("."):
+        if file.endswith("_Template.docx") or file.endswith("Template.docx"):
+            templates.append(file)
+    
+    print(f"Found templates in current directory: {templates}")
+    return templates
+
+def copy_templates_to_current_directory():
+    """
+    Copy templates from the templates directory to the current working directory
+    if they don't already exist.
+    
+    Returns:
+        list: List of copied template file paths
+    """
+    copied_templates = []
+    templates_dir = "templates"
+    
+    # Check if templates directory exists
+    if not os.path.exists(templates_dir):
+        print(f"Templates directory '{templates_dir}' not found.")
+        return copied_templates
+    
+    # Get list of template files in templates directory
+    template_files = [f for f in os.listdir(templates_dir) if f.endswith(".docx")]
+    
+    # Copy each template file to current directory if it doesn't exist
+    for template_file in template_files:
+        source_path = os.path.join(templates_dir, template_file)
+        dest_path = template_file
+        
+        if not os.path.exists(dest_path):
+            try:
+                import shutil
+                shutil.copy2(source_path, dest_path)
+                copied_templates.append(dest_path)
+                print(f"Copied template '{template_file}' to current directory.")
+            except Exception as e:
+                print(f"Error copying template '{template_file}': {e}")
+        else:
+            print(f"Template '{template_file}' already exists in current directory.")
+    
+    return copied_templates
+
+def copy_template_complex_elements(source_doc, target_doc):
+    """
+    Copy complex elements like headers and footers from source document to target document.
+    
+    Args:
+        source_doc: Source Document object
+        target_doc: Target Document object
+    """
+    try:
+        # Copy headers and footers
+        for i, section in enumerate(target_doc.sections):
+            # Skip if source doesn't have this many sections
+            if i >= len(source_doc.sections):
+                break
+                
+            # Copy header
+            if section.header.is_linked_to_previous == False:
+                # Check if there's at least one paragraph in the header
+                if len(section.header.paragraphs) == 0:
+                    section.header.add_paragraph()
+                
+                # Copy text and style from source header paragraphs
+                for j, para in enumerate(source_doc.sections[i].header.paragraphs):
+                    if j < len(section.header.paragraphs):
+                        section.header.paragraphs[j].text = para.text
+                        try:
+                            section.header.paragraphs[j].style = para.style
+                        except Exception:
+                            pass  # Style might not be compatible
+                    else:
+                        new_para = section.header.add_paragraph(para.text)
+                        try:
+                            new_para.style = para.style
+                        except Exception:
+                            pass
+            
+            # Copy footer
+            if section.footer.is_linked_to_previous == False:
+                # Check if there's at least one paragraph in the footer
+                if len(section.footer.paragraphs) == 0:
+                    section.footer.add_paragraph()
+                
+                # Copy text and style from source footer paragraphs
+                for j, para in enumerate(source_doc.sections[i].footer.paragraphs):
+                    if j < len(section.footer.paragraphs):
+                        section.footer.paragraphs[j].text = para.text
+                        try:
+                            section.footer.paragraphs[j].style = para.style
+                        except Exception:
+                            pass  # Style might not be compatible
+                    else:
+                        new_para = section.footer.add_paragraph(para.text)
+                        try:
+                            new_para.style = para.style
+                        except Exception:
+                            pass
+    except Exception as e:
+        print(f"Error copying complex elements: {e}")
+
+def create_tailored_resume_from_template(content, template_path, output_path):
+    """
+    Create a tailored resume by directly modifying a template document.
+    This preserves all formatting, tables, and styles from the original template.
+    
+    Args:
+        content: Structured content for the resume (text)
+        template_path: Path to the template document
+        output_path: Path to save the output document
+        
+    Returns:
+        bool: Success status
+    """
+    try:
+        if not os.path.exists(template_path):
+            return False
+            
+        # Create a copy of the template
+        doc = Document(template_path)
+        
+        # Parse the content into sections
+        sections = {}
+        current_section = None
+        current_content = []
+        
+        for line in content.split('\n'):
+            line = line.strip()
+            if not line:
+                continue
+                
+            # Check if this is a heading (all caps or ends with a colon)
+            if line.isupper() or (line.endswith(':') and len(line) < 50):
+                # Save the previous section
+                if current_section and current_content:
+                    sections[current_section] = current_content
+                
+                # Start a new section
+                current_section = line
+                current_content = []
+            else:
+                if current_section:
+                    current_content.append(line)
+        
+        # Save the last section
+        if current_section and current_content:
+            sections[current_section] = current_content
+        
+        # Find all paragraphs in the template that are headings or potential section markers
+        template_sections = {}
+        for i, para in enumerate(doc.paragraphs):
+            if para.style.name.startswith('Heading') or para.text.isupper() or para.runs and para.runs[0].bold:
+                template_sections[para.text.strip()] = i
+        
+        # Create a new document to avoid duplicate content
+        new_doc = Document()
+        
+        # Copy all styles from the template to the new document
+        for style in doc.styles:
+            if style.name not in new_doc.styles:
+                try:
+                    new_doc.styles.add_style(style.name, style.type)
+                except:
+                    pass  # Style might already exist or be built-in
+        
+        # Copy document properties and sections settings
+        # We'll only add sections as needed, not at the beginning
+        if len(doc.sections) > 0:
+            # Copy properties from the first section
+            section = doc.sections[0]
+            # Use the existing first section in the new document
+            new_section = new_doc.sections[0]
+            new_section.page_height = section.page_height
+            new_section.page_width = section.page_width
+            new_section.left_margin = section.left_margin
+            new_section.right_margin = section.right_margin
+            new_section.top_margin = section.top_margin
+            new_section.bottom_margin = section.bottom_margin
+            new_section.header_distance = section.header_distance
+            new_section.footer_distance = section.footer_distance
+            
+            # Copy additional sections if needed
+            for i in range(1, len(doc.sections)):
+                section = doc.sections[i]
+                new_section = new_doc.add_section()
+                new_section.page_height = section.page_height
+                new_section.page_width = section.page_width
+                new_section.left_margin = section.left_margin
+                new_section.right_margin = section.right_margin
+                new_section.top_margin = section.top_margin
+                new_section.bottom_margin = section.bottom_margin
+                new_section.header_distance = section.header_distance
+                new_section.footer_distance = section.footer_distance
+        
+        # Copy complex elements like headers and footers
+        copy_template_complex_elements(doc, new_doc)
+        
+        # Replace content in the template with our tailored content
+        # First, create a mapping between our sections and template sections
+        section_mapping = {}
+        for our_section in sections.keys():
+            best_match = None
+            best_score = 0
+            
+            for template_section in template_sections.keys():
+                # Calculate similarity between section headings
+                if template_section.upper() == our_section.upper():
+                    # Exact match
+                    best_match = template_section
+                    break
+                elif template_section.upper() in our_section.upper() or our_section.upper() in template_section.upper():
+                    # Partial match
+                    score = len(set(template_section.upper()) & set(our_section.upper())) / max(len(template_section), len(our_section))
+                    if score > best_score:
+                        best_score = score
+                        best_match = template_section
+            
+            if best_match and best_score > 0.5:
+                section_mapping[our_section] = best_match
+        
+        # Add content to the new document based on the template structure
+        for our_section, content_lines in sections.items():
+            # Add section heading
+            p = new_doc.add_paragraph()
+            
+            # Try to find a matching heading style from the template
+            if our_section in section_mapping:
+                template_section = section_mapping[our_section]
+                section_index = template_sections[template_section]
+                template_para = doc.paragraphs[section_index]
+                
+                try:
+                    p.style = template_para.style.name
+                except:
+                    p.style = 'Heading 1'  # Fallback
+                
+                # Copy formatting from template paragraph
+                for run in template_para.runs:
+                    if run.text.strip():
+                        p_run = p.add_run(our_section)
+                        p_run.bold = run.bold
+                        p_run.italic = run.italic
+                        p_run.underline = run.underline
+                        if run.font.name:
+                            p_run.font.name = run.font.name
+                        if run.font.size:
+                            p_run.font.size = run.font.size
+                        if run.font.color.rgb:
+                            p_run.font.color.rgb = run.font.color.rgb
+                        break
+                else:
+                    # If no runs with text, add a default run
+                    p_run = p.add_run(our_section)
+                    p_run.bold = True
+            else:
+                # No matching template section, use default formatting
+                p.style = 'Heading 1'
+                p_run = p.add_run(our_section)
+                p_run.bold = True
+            
+            # Add section content
+            for line in content_lines:
+                if line.startswith('•') or line.startswith('-') or line.startswith('*'):
+                    # This is a bullet point
+                    p = new_doc.add_paragraph(line[1:].strip(), style='List Bullet')
+                else:
+                    p = new_doc.add_paragraph(line)
+        
+        new_doc.save(output_path)
+        return True
+        
+    except Exception as e:
+        print(f"Error creating tailored resume from template: {e}")
+        return False
+
+def convert_text_to_word(text_file_path, output_docx_path):
+    """
+    Convert a text file to a Word document.
+    
+    Args:
+        text_file_path: Path to the text file
+        output_docx_path: Path where the Word document will be saved
+    
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        # Read the text file
+        with open(text_file_path, 'r', encoding='utf-8') as file:
+            content = file.read()
+        
+        # Create a new Word document
+        doc = Document()
+        
+        # Split the content by double newlines to identify paragraphs
+        paragraphs = content.split('\n\n')
+        
+        # Process each paragraph
+        for i, para_text in enumerate(paragraphs):
+            # Skip empty paragraphs
+            if not para_text.strip():
+                continue
+                
+            # Check if this looks like a heading (all caps or ends with a colon)
+            is_heading = para_text.isupper() or para_text.strip().endswith(':')
+            
+            # Add the paragraph to the document
+            paragraph = doc.add_paragraph(para_text.strip())
+            
+            # Apply formatting based on position and content
+            if i == 0:  # First paragraph is likely the name
+                paragraph.style = 'Title'
+            elif is_heading:
+                paragraph.style = 'Heading 2'
+            else:
+                paragraph.style = 'Normal'
+        
+        # Save the document
+        doc.save(output_docx_path)
+        return True
+        
+    except Exception as e:
+        print(f"Error converting text to Word: {e}")
+        return False
+
+def convert_sample_resumes():
+    """
+    Convert all sample text resumes to Word documents.
+    
+    Returns:
+        list: Paths to the created Word documents
+    """
+    sample_files = [
+        "excellent_match_resume.docx.txt",
+        "good_match_resume.docx.txt",
+        "average_match_resume.docx.txt",
+        "poor_match_resume.docx.txt"
+    ]
+    
+    created_files = []
+    
+    for text_file in sample_files:
+        if os.path.exists(text_file):
+            output_path = text_file.replace('.docx.txt', '.docx')
+            print(f"Converting {text_file} to {output_path}...")
+            if convert_text_to_word(text_file, output_path):
+                created_files.append(output_path)
+                print(f"Successfully created {output_path}")
+            else:
+                print(f"Failed to create {output_path}")
+        else:
+            print(f"Sample file not found: {text_file}")
+    
+    return created_files

create_templates.py

@@ -0,0 +1,31 @@
+import os
+import sys
+
+# Add the templates directory to the Python path
+templates_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "templates")
+sys.path.append(templates_dir)
+
+# Import the template creation functions
+from create_templates import (
+    create_professional_template,
+    create_modern_template,
+    create_academic_template
+)
+
+def main():
+    """Create resume templates in the current working directory."""
+    print("Creating resume templates in the current directory...")
+    
+    # Create templates
+    create_professional_template()
+    create_modern_template()
+    create_academic_template()
+    
+    print("All templates created successfully in the current directory!")
+    
+    # List created templates
+    templates = [f for f in os.listdir(".") if f.endswith("_Template.docx")]
+    print(f"Templates available: {templates}")
+
+if __name__ == "__main__":
+    main() 

excellent_match_resume.docx.txt

@@ -0,0 +1,55 @@
+MICHAEL JOHNSON
+Senior Software Architect
+[email protected] | (555) 123-4567 | linkedin.com/in/michaeljohnson
+San Francisco, CA | Remote Available
+
+PROFESSIONAL SUMMARY
+Innovative Software Architect with 12+ years of experience designing and implementing scalable, high-performance enterprise applications. Expert in cloud architecture, microservices, and distributed systems with a proven track record of delivering complex solutions. Skilled in translating business requirements into robust technical designs while mentoring development teams and promoting best practices.
+
+SKILLS
+• Cloud Platforms: AWS (Certified Solutions Architect), Azure, GCP
+• Architecture: Microservices, Event-driven, Serverless, API Design (REST, GraphQL)
+• Containerization: Docker, Kubernetes, ECS
+• Programming: Java, Python, TypeScript, C#
+• DevOps: CI/CD, Jenkins, GitHub Actions, ArgoCD
+• Infrastructure as Code: Terraform, CloudFormation
+• Databases: PostgreSQL, MongoDB, DynamoDB, Cassandra
+• Messaging: Kafka, RabbitMQ, AWS Kinesis
+• Security: OAuth, JWT, API Gateway
+
+PROFESSIONAL EXPERIENCE
+
+SENIOR SOFTWARE ARCHITECT | Cloudwave Technologies | 2019 - Present
+• Led the architectural redesign of a monolithic application into a microservices architecture, resulting in 40% improved scalability and 30% reduced deployment time
+• Designed and implemented cloud-native solutions on AWS using containerization (Docker, Kubernetes) and serverless technologies (Lambda, API Gateway)
+• Created comprehensive architecture documentation and technical specifications for enterprise applications
+• Established CI/CD pipelines using Jenkins and GitHub Actions, reducing deployment errors by 75%
+• Mentored a team of 15 developers on best practices in software architecture and cloud technologies
+• Implemented event-driven architecture using Kafka for real-time data processing, handling 10M+ daily events
+• Designed and optimized database schemas across SQL and NoSQL databases for high-performance applications
+
+LEAD SOFTWARE ENGINEER | TechInnovate Solutions | 2015 - 2019
+• Architected and developed a distributed system handling 5,000+ concurrent users with 99.99% uptime
+• Led the migration of on-premises applications to AWS, reducing infrastructure costs by 35%
+• Designed RESTful and GraphQL APIs for internal and external consumption
+• Implemented microservices using Spring Boot and Docker, improving system modularity and maintainability
+• Created architecture blueprints and technical documentation for development teams
+• Collaborated with product managers to translate business requirements into technical solutions
+• Introduced automated testing frameworks, increasing code coverage from 60% to 90%
+
+SOFTWARE ENGINEER | Global Systems Inc. | 2011 - 2015
+• Developed enterprise Java applications using Spring Framework
+• Designed and implemented database schemas and stored procedures in PostgreSQL
+• Created front-end interfaces using Angular and React
+• Participated in agile development processes, including daily stand-ups and sprint planning
+• Contributed to architectural decisions for new product features
+
+EDUCATION
+• Master of Science in Computer Science, Stanford University, 2011
+• Bachelor of Science in Software Engineering, University of California, Berkeley, 2009
+
+CERTIFICATIONS
+• AWS Certified Solutions Architect - Professional
+• Microsoft Azure Solutions Architect Expert
+• Certified Kubernetes Administrator (CKA)
+• Professional Scrum Master I (PSM I) 

find_error.py

@@ -0,0 +1,16 @@
+import re
+
+def find_problematic_fstrings(file_path):
+    with open(file_path, 'r', encoding='utf-8') as file:
+        lines = file.readlines()
+    
+    for i, line in enumerate(lines):
+        # Look for f-strings with backslashes
+        if 'f"' in line or "f'" in line:
+            # Check if there's a backslash in the f-string
+            match = re.search(r'f["\'].*?\\.*?["\']', line)
+            if match:
+                print(f"Potential problematic f-string at line {i+1}: {line.strip()}")
+
+if __name__ == "__main__":
+    find_problematic_fstrings("backend.py") 

good_match_resume.docx.txt

@@ -0,0 +1,52 @@
+SARAH WILLIAMS
+Software Architect
+[email protected] | (555) 987-6543 | linkedin.com/in/sarahwilliams
+Chicago, IL | Remote Available
+
+PROFESSIONAL SUMMARY
+Dedicated Software Architect with 9 years of experience in designing and implementing software solutions for enterprise applications. Skilled in cloud architecture and microservices with a focus on scalable and maintainable systems. Strong communicator with experience guiding development teams and collaborating with stakeholders.
+
+SKILLS
+• Cloud Platforms: AWS, Azure
+• Architecture: Microservices, Service-oriented Architecture
+• Containerization: Docker, Kubernetes
+• Programming: Java, Python, JavaScript
+• DevOps: CI/CD, Jenkins
+• Databases: MySQL, MongoDB
+• API Design: REST
+• Tools: Git, JIRA, Confluence
+
+PROFESSIONAL EXPERIENCE
+
+SOFTWARE ARCHITECT | Enterprise Solutions Inc. | 2018 - Present
+• Design and develop software architecture for enterprise applications serving 1M+ users
+• Create detailed architecture specifications and documentation for development teams
+• Lead the migration from monolithic to microservices architecture, improving system scalability
+• Implement containerization using Docker and Kubernetes for consistent deployment
+• Collaborate with product managers to translate business requirements into technical solutions
+• Guide a team of 8 developers in implementing architectural designs
+• Evaluate and select appropriate technologies and frameworks for new projects
+• Ensure system scalability, reliability, and security through proper architectural patterns
+
+SENIOR SOFTWARE DEVELOPER | TechSolutions Corp | 2015 - 2018
+• Developed and maintained enterprise Java applications using Spring Framework
+• Participated in architectural decisions for new features and system improvements
+• Implemented RESTful APIs for internal and external service integration
+• Designed database schemas and optimized queries for performance
+• Collaborated with QA team to ensure code quality and test coverage
+• Mentored junior developers on coding standards and best practices
+• Participated in agile development processes, including sprint planning and retrospectives
+
+SOFTWARE DEVELOPER | Digital Innovations | 2013 - 2015
+• Developed web applications using Java, JavaScript, and HTML/CSS
+• Created and maintained database schemas in MySQL
+• Implemented unit and integration tests to ensure code quality
+• Participated in code reviews and provided feedback to team members
+• Collaborated with UX designers to implement user interfaces
+
+EDUCATION
+• Bachelor of Science in Computer Science, University of Illinois, 2013
+
+CERTIFICATIONS
+• AWS Certified Solutions Architect - Associate
+• Certified Scrum Developer 

job_desc.txt

@@ -0,0 +1,43 @@
+Software Architect
+Location: Remote (US)
+Salary: $150,000 - $180,000
+
+About the Role:
+We are seeking an experienced Software Architect to design and oversee the implementation of high-performance, scalable software systems. The ideal candidate will have a strong background in cloud architecture, microservices, and distributed systems, with a proven track record of delivering complex software solutions.
+
+Key Responsibilities:
+• Design and develop software architecture for enterprise applications
+• Create detailed architecture specifications and documentation
+• Collaborate with product managers to translate business requirements into technical solutions
+• Guide development teams in implementing architectural designs
+• Evaluate and select appropriate technologies and frameworks
+• Ensure system scalability, reliability, and security
+• Mentor junior developers and promote best practices
+• Stay current with emerging technologies and industry trends
+
+Required Skills and Experience:
+• 8+ years of software development experience
+• 5+ years in software architecture roles
+• Expert knowledge of cloud platforms (AWS, Azure, or GCP)
+• Strong experience with microservices architecture
+• Proficiency in at least one major programming language (Java, Python, C#, or JavaScript/TypeScript)
+• Experience with containerization (Docker, Kubernetes)
+• Knowledge of CI/CD pipelines and DevOps practices
+• Understanding of database design (SQL and NoSQL)
+• Experience with API design and implementation (REST, GraphQL)
+• Strong communication and leadership skills
+
+Preferred Qualifications:
+• Experience with event-driven architecture
+• Knowledge of serverless computing
+• Experience with data streaming platforms (Kafka, Kinesis)
+• Understanding of machine learning frameworks
+• Experience with infrastructure as code (Terraform, CloudFormation)
+• Relevant certifications (AWS Solutions Architect, Azure Solutions Architect, etc.)
+• Experience in agile development methodologies
+
+Education:
+• Bachelor's degree in Computer Science, Software Engineering, or related field
+• Master's degree preferred
+
+We offer competitive compensation, excellent benefits, and the opportunity to work on cutting-edge technologies in a collaborative environment. Join our team and help shape the future of our software platforms!

poor_match_resume.docx.txt

@@ -0,0 +1,52 @@
+JENNIFER SMITH
+Frontend Developer
+[email protected] | (555) 234-5678 | linkedin.com/in/jennifersmith
+New York, NY | On-site Only
+
+PROFESSIONAL SUMMARY
+Creative Frontend Developer with 3 years of experience crafting engaging user interfaces and responsive web designs. Passionate about creating intuitive user experiences with modern web technologies. Strong attention to detail and commitment to writing clean, maintainable code.
+
+SKILLS
+• Frontend: HTML5, CSS3, JavaScript, React, Vue.js
+• Design: Figma, Adobe XD, Photoshop
+• CSS Frameworks: Bootstrap, Tailwind CSS
+• Version Control: Git, GitHub
+• Tools: VS Code, Chrome DevTools
+• Basic Knowledge: Node.js, Express
+
+PROFESSIONAL EXPERIENCE
+
+FRONTEND DEVELOPER | Creative Web Solutions | 2020 - Present
+• Develop responsive web interfaces using HTML, CSS, and JavaScript
+• Create interactive UI components using React and Vue.js
+• Collaborate with designers to implement pixel-perfect designs
+• Optimize website performance and loading times
+• Ensure cross-browser compatibility and responsive design
+• Implement animations and transitions for enhanced user experience
+• Participate in code reviews and provide feedback to team members
+
+JUNIOR WEB DEVELOPER | Digital Design Agency | 2019 - 2020
+• Assisted in the development of client websites using HTML, CSS, and JavaScript
+• Created responsive layouts using Bootstrap
+• Fixed UI bugs and implemented minor features
+• Collaborated with designers to implement visual elements
+• Participated in client meetings and gathered requirements
+• Learned and applied new frontend technologies and frameworks
+
+WEB DESIGN INTERN | Tech Startups Inc. | 2018 - 2019
+• Assisted in designing and developing website mockups
+• Created UI elements using Photoshop and Illustrator
+• Implemented basic web pages using HTML and CSS
+• Learned about responsive design principles
+• Participated in team meetings and brainstorming sessions
+
+EDUCATION
+• Bachelor of Fine Arts in Graphic Design, New York University, 2018
+
+CERTIFICATIONS
+• Meta Frontend Developer Professional Certificate
+• FreeCodeCamp Responsive Web Design Certification
+
+PORTFOLIO
+• Personal website: jennifersmith.design
+• GitHub: github.com/jennifersmith 

requirements.txt

@@ -0,0 +1,11 @@
+gradio>=4.0.0
+openai>=1.0.0
+python-docx>=0.8.11
+docx2txt>=0.8
+PyPDF2>=3.0.0
+plotly>=5.14.0
+python-dotenv>=1.0.0
+requests>=2.28.0
+numpy>=1.24.0
+pandas>=2.0.0
+matplotlib>=3.7.0