Upload 25 files

README.md

@@ -1,12 +1,28 @@
----
-title: Ats Optimizer
-emoji: 🏢
-colorFrom: blue
-colorTo: red
-sdk: streamlit
-sdk_version: 1.44.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ATS Optimizer Pro
+
+Complete solution to optimize resumes for applicant tracking systems.
+
+## Features
+
+1. **Format-Preserving Analysis**  
+   - Parses PDF/Word resumes while keeping original formatting
+   - Advanced section detection
+
+2. **5-Factor ATS Scoring**  
+   - Keyword matching (TF-IDF + exact match)  
+   - Section completeness  
+   - Semantic similarity (Qdrant vectors)  
+   - Experience matching  
+   - Education verification  
+
+3. **AI-Powered Optimization**  
+   - DeepSeek API integration  
+   - 3-step iterative refinement  
+   - Format-aware rewriting  
+
+## Setup
+
+1. Install requirements:
+   ```bash
+   pip install -r requirements.txt
+   python -m spacy download en_core_web_md

app.py

@@ -0,0 +1,139 @@
+import streamlit as st
+from ats_optimizer.core import ResumeAnalyzer, ResumeOptimizer
+from ats_optimizer.data_models import Resume, JobDescription
+from ats_optimizer.utils.file_handlers import FileHandler  # Updated import
+# from ats_optimizer.utils import FileHandler, Config
+from ats_optimizer.utils.config_manager import Config
+from pathlib import Path
+import tempfile
+import sys
+
+# Fix module imports for Hugging Face
+sys.path.append(str(Path(__file__).parent))
+
+# def main():
+#     # Initialize components
+#     config = Config('config.yaml')
+#     analyzer = ResumeAnalyzer()
+#     optimizer = ResumeOptimizer(config.deepseek_api_key)
+    
+#     # Streamlit UI
+#     st.title("🚀 ATS Optimizer Pro")
+#     st.markdown("Upload your resume and job description to analyze and optimize for ATS compatibility")
+
+#     # File upload section
+#     with st.expander("Upload Files", expanded=True):
+#         col1, col2 = st.columns(2)
+#         with col1:
+#             resume_file = st.file_uploader("Resume", type=["pdf", "docx"], key="resume_upload")
+#         with col2:
+#             jd_file = st.file_uploader("Job Description", type=["pdf", "docx", "txt"], key="jd_upload")
+
+#     if st.button("Analyze", type="primary"):
+#         if resume_file and jd_file:
+#             with st.spinner("Processing files..."):
+#                 try:
+#                     # Save uploaded files
+#                     with tempfile.TemporaryDirectory() as temp_dir:
+#                         resume_path = FileHandler.save_uploaded_file(resume_file, temp_dir)
+#                         jd_path = FileHandler.save_uploaded_file(jd_file, temp_dir)
+                        
+#                         if not resume_path or not jd_path:
+#                             st.error("Failed to process uploaded files")
+#                             return
+                        
+#                         # Analyze documents
+#                         resume = analyzer.parse_resume(resume_path)
+#                         jd = analyzer.parse_jd(jd_path)
+                        
+#                         # Calculate score
+#                         score = analyzer.calculate_ats_score(resume, jd)
+                        
+#                         # Display results
+#                         st.subheader("📊 Analysis Results")
+#                         st.metric("Overall ATS Score", f"{score['overall_score']:.1f}%")
+                        
+#                         with st.expander("Detailed Scores"):
+#                             st.write(f"Keyword Match: {score['keyword_score']:.1f}%")
+#                             st.write(f"Section Completeness: {score['section_score']:.1f}%")
+#                             st.write(f"Experience Match: {score['experience_score']:.1f}%")
+                        
+#                         # Optimization section
+#                         st.subheader("🛠 Optimization")
+#                         if st.button("Optimize Resume", key="optimize_btn"):
+#                             with st.spinner("Rewriting resume..."):
+#                                 optimized = optimizer.rewrite_resume(resume, jd)
+#                                 temp_output = Path(temp_dir) / "optimized_resume.docx"
+#                                 FileHandler.save_resume(optimized, str(temp_output))
+                                
+#                                 st.success("Optimization complete!")
+#                                 with open(temp_output, "rb") as f:
+#                                     st.download_button(
+#                                         "Download Optimized Resume",
+#                                         data=f,
+#                                         file_name="optimized_resume.docx",
+#                                         mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+#                                     )
+                
+#                 except Exception as e:
+#                     st.error(f"An error occurred: {str(e)}")
+#                     st.stop()
+#         else:
+#             st.warning("Please upload both resume and job description files")
+
+# if __name__ == "__main__":
+#     main()
+
+def main():
+    # Initialize components
+    config = Config('config.yaml')
+    analyzer = ResumeAnalyzer()
+    optimizer = ResumeOptimizer(config.deepseek_api_key)
+    
+    # Streamlit UI
+    st.title("ATS Optimizer Pro")
+    
+    # File upload
+    resume_file = st.file_uploader("Upload Resume", type=["pdf", "docx"])
+    jd_file = st.file_uploader("Upload Job Description", type=["pdf", "docx", "txt"])
+    
+    if st.button("Analyze"):
+        if resume_file and jd_file:
+            with st.spinner("Processing..."):
+                try:
+                    # Create temp directory
+                    with tempfile.TemporaryDirectory() as temp_dir:
+                        # Save uploaded files
+                        resume_path = FileHandler.save_uploaded_file(resume_file, temp_dir)
+                        jd_path = FileHandler.save_uploaded_file(jd_file, temp_dir)
+                        
+                        if not resume_path or not jd_path:
+                            st.error("Failed to process uploaded files")
+                            return
+                        
+                        # Analyze documents
+                        resume = analyzer.parse_resume(resume_path)
+                        jd = analyzer.parse_jd(jd_path)
+                        
+                        # Calculate score
+                        score = analyzer.calculate_ats_score(resume, jd)
+                        
+                        # Display results
+                        st.subheader("Analysis Results")
+                        st.json(score)
+                        
+                        # Optimization
+                        if st.button("Optimize Resume"):
+                            optimized = optimizer.rewrite_resume(resume, jd)
+                            output_path = os.path.join(temp_dir, "optimized_resume.docx")
+                            if FileHandler.save_resume(optimized, output_path):
+                                with open(output_path, "rb") as f:
+                                    st.download_button(
+                                        "Download Optimized Resume",
+                                        data=f,
+                                        file_name="optimized_resume.docx"
+                                    )
+                except Exception as e:
+                    st.error(f"An error occurred: {str(e)}")
+        else:
+            st.warning("Please upload both resume and job description files")

config.yaml

@@ -0,0 +1,18 @@
+deepseek:
+  api_key: "sk-cf0b89ca56e44cb9980113909ebe687e"
+  model: "deepseek-chat"
+  temperature: 0.7
+
+google_sheets:
+  enabled: true # Set to true if using Google Sheets or else false
+  credentials: "credentials.json"
+  # sheet_id: "your-sheet-id"
+  sheet_name: "Job Applications"
+
+scoring:
+  weights:
+    keyword: 0.3
+    section: 0.2
+    vector: 0.25
+    experience: 0.15
+    education: 0.1

core/__init__.py

@@ -0,0 +1,10 @@
+# from .analyzer import ResumeAnalyzer
+# from .optimizer import ResumeOptimizer
+# from .tracker import ApplicationTracker
+
+from ats_optimizer.core.analyzer import ResumeAnalyzer
+from ats_optimizer.core.optimizer import ResumeOptimizer
+from ats_optimizer.core.tracker import ApplicationTracker
+
+__all__ = ['ResumeAnalyzer', 'ResumeOptimizer', 'ApplicationTracker']
+# __all__ = ['ResumeAnalyzer', 'ResumeOptimizer'] #if doesnt want to use tracker & comment above import too

core/analyzer.py

@@ -0,0 +1,41 @@
+from qdrant_client import QdrantClient
+from ats_optimizer.data_models.resume import Resume
+from ats_optimizer.data_models.job_description import JobDescription
+# from utils.logger import logger
+# from ..utils.logger import logger
+from ats_optimizer.utils.logger import logger
+
+class ResumeAnalyzer:
+    def __init__(self):
+        self.client = QdrantClient(":memory:")
+        self.client.set_model("BAAI/bge-base-en")
+    
+    def parse_resume(self, file_path: str) -> Resume:
+        """Step 1: Parse resume with formatting preservation"""
+        # Uses python-docx for Word docs, pdfminer for PDFs
+        raw_text, formatting = FileHandler.extract_with_formatting(file_path)
+        return Resume(raw_text, formatting)
+    
+    def parse_jd(self, file_path: str) -> JobDescription:
+        """Step 2: Analyze job description"""
+        raw_text = FileHandler.extract_text(file_path)
+        return JobDescription(raw_text)
+    
+    def calculate_ats_score(self, resume: Resume, jd: JobDescription) -> dict:
+        """Step 3: Comprehensive ATS scoring"""
+        # Enhanced scoring with 5 factors
+        scores = {
+            'keyword': self._keyword_match_score(resume, jd),
+            'section': self._section_completeness(resume, jd),
+            'vector': self._vector_similarity(resume, jd),
+            'experience': self._experience_match(resume, jd),
+            'education': self._education_match(resume, jd)
+        }
+        scores['overall'] = sum(w * s for w, s in [
+            (0.3, scores['keyword']),
+            (0.2, scores['section']),
+            (0.25, scores['vector']),
+            (0.15, scores['experience']),
+            (0.1, scores['education'])
+        ])
+        return scores

core/form_filler/background.js

@@ -0,0 +1,10 @@
+chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
+    if (request.action === "fillForm") {
+      chrome.tabs.query({active: true, currentWindow: true}, (tabs) => {
+        chrome.tabs.sendMessage(tabs[0].id, {
+          action: "fillFields",
+          resumeData: request.data
+        });
+      });
+    }
+  });

core/form_filler/content.js

@@ -0,0 +1,14 @@
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+    if (msg.action === "fillFields") {
+      const fields = {
+        'input[name*="name"]': msg.resumeData.name,
+        'input[name*="email"]': msg.resumeData.email,
+        'textarea[name*="experience"]': msg.resumeData.experience
+      };
+      
+      Object.entries(fields).forEach(([selector, value]) => {
+        const el = document.querySelector(selector);
+        if (el) el.value = value;
+      });
+    }
+  });

core/form_filler/manifest.json

@@ -0,0 +1,17 @@
+{
+    "manifest_version": 3,
+    "name": "ATS AutoFill",
+    "version": "1.0",
+    "permissions": ["activeTab", "storage"],
+    "action": {
+      "default_popup": "popup.html",
+      "default_icon": "icon.png"
+    },
+    "background": {
+      "service_worker": "background.js"
+    },
+    "content_scripts": [{
+      "matches": ["*://*/*"],
+      "js": ["content.js"]
+    }]
+  }

core/form_filler/popup.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>ATS AutoFill</title>
+    <script src="popup.js"></script>
+</head>
+<body>
+    <button id="fillButton">Fill Form</button>
+</body>
+</html>

core/optimizer.py

@@ -0,0 +1,39 @@
+import requests
+from docx import Document
+from data_models.resume import Resume
+
+from ats_optimizer.data_models.job_description import JobDescription
+from ats_optimizer.data_models.resume import Resume
+
+class ResumeOptimizer:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        # self.template = "templates/professional.docx"
+        self.template = "templates/Ramen_DXC.docx"
+    
+    def rewrite_resume(self, resume: Resume, jd: JobDescription) -> Resume:
+        """Step 4: AI rewriting with formatting preservation"""
+        prompt = self._build_optimization_prompt(resume, jd)
+        
+        response = requests.post(
+            "https://api.deepseek.com/v1/chat/completions",
+            headers={"Authorization": f"Bearer {self.api_key}"},
+            json={
+                "model": "deepseek-chat",
+                "messages": [{
+                    "role": "user",
+                    "content": prompt
+                }],
+                "temperature": 0.7
+            }
+        )
+        
+        # Apply optimized content to original format
+        optimized_content = response.json()["choices"][0]["message"]["content"]
+        return self._apply_formatting(resume, optimized_content)
+    
+    def _apply_formatting(self, original: Resume, new_content: str) -> Resume:
+        """Preserve original formatting with new content"""
+        doc = Document(original.file_path)
+        # Advanced formatting preservation logic
+        return Resume.from_docx(doc, new_content)

core/tracker.py

@@ -0,0 +1,57 @@
+import gspread
+from oauth2client.service_account import ServiceAccountCredentials
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+'''
+class ApplicationTracker:
+    def __init__(self, creds_path: str):
+        self.scope = ["https://www.googleapis.com/auth/spreadsheets"]
+        self.creds = ServiceAccountCredentials.from_json_keyfile_name(creds_path, self.scope)
+    
+    def track(self, application_data: dict):
+        """Track application in Google Sheets with enhanced fields"""
+        client = gspread.authorize(self.creds)
+        sheet = client.open("Job Applications").sheet1
+        
+        sheet.append_row([
+            application_data['company'],
+            application_data['position'],
+            application_data['date'],
+            application_data['status'],
+            application_data['score'],
+            application_data['url'],
+            application_data['resume_version'],
+            application_data['notes']
+        ])
+'''
+class ApplicationTracker:
+    def __init__(self, creds_path: str):
+        if not Path(creds_path).exists():
+            raise FileNotFoundError(f"Credentials file not found at {creds_path}")
+        
+        try:
+            self.scope = ["https://www.googleapis.com/auth/spreadsheets"]
+            self.creds = ServiceAccountCredentials.from_json_keyfile_name(creds_path, self.scope)
+            self.client = gspread.authorize(self.creds)
+        except Exception as e:
+            logger.error(f"Google Sheets auth failed: {e}")
+            raise
+
+    def track(self, application_data: dict, sheet_name="Job Applications"):
+        try:
+            sheet = self.client.open(sheet_name).sheet1
+            sheet.append_row([
+                application_data.get('company', ''),
+                application_data.get('position', ''),
+                application_data.get('date_applied', ''),
+                application_data.get('status', 'Applied'),
+                application_data.get('score', ''),
+                application_data.get('url', '')
+            ])
+            return True
+        except Exception as e:
+            logger.error(f"Tracking failed: {e}")
+            return False

credentials.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "formal-theater-458022-d2",
+  "private_key_id": "e7494ef90b6d43b0dc15ce9f9db0922225a48694",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDDGjEU29ETZSyx\nqr8zakizg+q3IqWq3pQdMVHH72GLq/vugkZiqao11YdFK3igyKIRApacpLAACjmm\nEoUwcKEh1R7WKExbAvyFTLIm65j9wZ2Z2LeAuRRZFjU2uQ+iCXOTQA7YgIPU3sMg\nLI+cMAITr0C4hLRnjgUcPeNQRG8M/Io3Oq4KeTDvEKS99aqVvA7zgGH98awdBd2c\ncciYGHaTUq5sJxK72AKFnPxrLHgbq9hiuc5fw7YdCVzmuVY/LXkwSkosbIsIrxUx\nPHwlnYdoWHZ0aI76x3qluw+MUqZoIEp3ctkIfHaZbLf4yuqTcbUuQ7RtkPFLifge\ndFsM7BnhAgMBAAECggEASLQr8h/wC5A6VYLReXFz4iGYh+JLZh9HhpFobl8QNKJE\nYZ7+Z6neGe2WWPpYG2JosnoKchkU1Q76aJ6iL2jpQthOg3PE8G1ueKYaBVLqUjWi\na0BNMZTGtmQGNHxGDRYEkazfW2KYvey9PfIdGhDx1TALqDcbmzNbSCjv2muGDoou\nzmEcAzdil5M0UNVctqxqAOk4PK3l59dSUdRgJLP6LsceT1xqNDw9Ps9x8vOUY3iq\n0kkOeXu+eTVIkgTxIsJGnBQ0wr+Ao5r12zJ8Y/iyXDVN/RTOl+aakegYiIYjeVZu\nEPyZ2fMNnQCtfSGzoLrcHyFxkhh1Fl2E4ZhW4hWh+QKBgQDgjtlnhBdhNuBGHOp0\nknRKWlhtRXzuIDklCmIS/vK0ZXpCF2wacXo7UKHQ7oVPsA5+0MqeV9teu8hqQm/Y\nZRipHU911zlsR81ZejR4WQ8xDci4Ewpt5JVkx+DfPlNXuPapgGTtg/KBDfKHWnnv\nNr/BSeRSNb5iSPkS/j4ENnrhEwKBgQDea4U0cy9J2YvBhOmb/Bk9fOIBcnlz/B2v\nWt/+ddIZnW1IOYgSd/W8W3GyQ803OzzuHa+y0vLNnGBwapOMPJ8foagy36XYbRxr\nSu8He+oTTJTgwidEnUz1DS8B3IIgi+FJK8YLUL8hVupuBqqI/r9G/wtULTFutzvD\n5/N/rCaruwKBgADOIlNvstHDa5x0wBZ46/fUSRrjM+Z6sRnD5sQgq+gfsQeJo/aY\nT5Lk4B+qq0m03OhxgTh+Iig9ziMrZ9FD04nPtBg9FFSiEUdv275Ou3I2lXCriM8K\nEcsRuGm0hIH9BM1oy3PalEUIMsVvep5z+M4NoMb2sF8T2ejKhphnRZuHAoGAL+rM\nFMOn8WoLwNJIndFPAr8v1Y36+nDbWFbkoOZzMA+JZqD2Xrw3VbABq50NzhNWChqd\nKpJlusQwxqc/SFwbD+581RD3osvG7pqDKoKYqDW8cTuCyDZ3SOfhM6503lwkWeYz\nUWbA9obKFJAdF0yCmuIBZ84gszCIkKkc/WlyH1cCgYEAtkmceBmt/YCPnaVDhk/L\n4hWqcVHqD2RU4DPPhjIXppjahDrcOzjD7Lt9swKK3QZEE840DcIAKVU140V2Neie\nOXqzgrLn/dIe0j15FK4lmY9GhCVU3kTx08JwxEiBIDoi0Z6F926C9dvjGxarpsi7\n77pNNpxzZ9i6mx9dK9ECuMI=\n-----END PRIVATE KEY-----\n",
+  "client_email": "[email protected]",
+  "client_id": "102212927624577642135",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/ats-optimizer%40formal-theater-458022-d2.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

data_models/__init__.py

@@ -0,0 +1,5 @@
+# from .resume import Resume
+from .resume import Resume
+from .job_description import JobDescription
+
+__all__ = ['Resume', 'JobDescription']

data_models/job_description.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Dict, List
+
+@dataclass
+class JobDescription:
+    # raw_text: str
+    # extracted_keywords: List[str]
+    # keyterms: List[tuple]
+    # entities: List[str]
+    raw_text: str
+    extracted_keywords: list
+    keyterms: list
+    entities: list
+    
+    @property
+    def required_skills(self) -> List[str]:
+        return [kw for kw in self.extracted_keywords if 'skill' in kw.lower()]
+    
+    @property
+    def experience_requirements(self) -> Dict:
+        return {
+            'years': self._extract_years(),
+            'technologies': self._extract_tech()
+        }
+    
+    def _extract_years(self) -> int:
+        # Extract years requirement using regex
+        pass
+    
+    def _extract_tech(self) -> List[str]:
+        # Extract required technologies
+        pass

data_models/resume.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Dict, List
+
+@dataclass
+class Resume:
+    # raw_text: str
+    # formatting: Dict
+    # metadata: Dict
+    # scores: Dict = None
+    raw_text: str
+    extracted_keywords: list
+    keyterms: list
+    entities: list
+    
+    @classmethod
+    def from_docx(cls, file_path: str):
+        """Parse while preserving formatting"""
+        text, formatting = parse_docx_with_formatting(file_path)
+        return cls(text, formatting, extract_metadata(text))
+    
+    def to_docx(self, output_path: str):
+        """Export with original formatting"""
+        apply_formatting(self.raw_text, self.formatting, output_path)

requirement.txt

@@ -0,0 +1,22 @@
+# Core
+python-docx==0.8.11
+pdfminer.six==20221105
+#python-docx-template==0.16.0
+docxtpl==0.16.0
+pdf2docx==0.5.6
+qdrant-client==1.6.4
+sentence-transformers==2.2.2
+
+# API & Services
+google-api-python-client==2.104.0
+gspread==5.11.3
+requests==2.31.0
+oauth2client==4.1.3
+
+# UI
+streamlit==1.29.0
+plotly==5.18.0
+
+# NLP
+spacy==3.7.2
+en-core-web-md @ https://github.com/explosion/spacy-models/releases/download/en_core_web_md-3.7.0/en_core_web_md-3.7.0-py3-none-any.whl

setup.py

@@ -0,0 +1,16 @@
+# setup.py
+from setuptools import setup, find_packages
+
+setup(
+    name="ats_optimizer",
+    version="0.1",
+    packages=find_packages(),
+    install_requires=[
+        'python-docx>=0.8.11',
+        'pdfminer.six>=20221105',
+        'pyyaml>=6.0',
+        'streamlit>=1.28.0',
+        'spacy>=3.7.2',
+    ],
+    python_requires='>=3.9',
+)

utils/__init__.py

@@ -0,0 +1,5 @@
+from .file_handlers import FileHandler
+from .logger import setup_logger
+from .config_manager import Config
+
+__all__ = ['FileHandler', 'setup_logger', 'Config']

utils/config_manager.py

@@ -0,0 +1,9 @@
+import yaml
+
+class Config:
+    def __init__(self, config_path: str):
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)
+        
+    def __getattr__(self, name):
+        return self.config.get(name)

utils/file_handlers.py

@@ -0,0 +1,69 @@
+import os
+from docx import Document
+from pdfminer.high_level import extract_text
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+import uuid
+
+class FileHandler:
+    @staticmethod
+    def read_file(file_path: str) -> str:
+        if file_path.endswith('.docx'):
+            return FileHandler._read_docx(file_path)
+        elif file_path.endswith('.pdf'):
+            return extract_text(file_path)
+        else:
+            with open(file_path, 'r') as f:
+                return f.read()
+    #--
+    
+    @staticmethod
+    def save_uploaded_file(uploaded_file, directory="temp_uploads"):
+        """Save Streamlit uploaded file to a temporary directory"""
+        try:
+            # Create directory if it doesn't exist
+            Path(directory).mkdir(exist_ok=True)
+            
+            # Generate unique filename
+            file_ext = Path(uploaded_file.name).suffix
+            unique_id = uuid.uuid4().hex
+            temp_file = Path(directory) / f"{unique_id}{file_ext}"
+            
+            # Save file
+            with open(temp_file, "wb") as f:
+                f.write(uploaded_file.getbuffer())
+            
+            return str(temp_file)
+        except Exception as e:
+            print(f"Error saving file: {e}")
+            return None
+
+    @staticmethod
+    def cleanup_temp_files(directory="temp_uploads"):
+        """Remove temporary files"""
+        try:
+            for file in Path(directory).glob("*"):
+                file.unlink()
+        except Exception as e:
+            print(f"Error cleaning files: {e}")
+   #--
+   
+    @staticmethod
+    def _read_docx(file_path: str) -> str:
+        doc = Document(file_path)
+        return '\n'.join([para.text for para in doc.paragraphs])
+    
+    @staticmethod
+    def save_resume(resume_data: dict, output_path: str):
+        if output_path.endswith('.docx'):
+            FileHandler._save_as_docx(resume_data, output_path)
+        else:
+            with open(output_path, 'w') as f:
+                f.write(resume_data['content'])
+
+    @staticmethod
+    def _save_as_docx(resume_data: dict, output_path: str):
+        doc = Document()
+        # Add formatting preservation logic here
+        doc.save(output_path)
+    

utils/file_handlers1.py

@@ -0,0 +1,55 @@
+import os
+from pathlib import Path
+import uuid
+from docx import Document
+from pdfminer.high_level import extract_text
+
+class FileHandler:
+    @staticmethod
+    def save_uploaded_file(uploaded_file, directory="temp_uploads"):
+        """Save Streamlit uploaded file to temporary directory"""
+        try:
+            # Create directory if needed
+            Path(directory).mkdir(exist_ok=True)
+            
+            # Generate unique filename
+            file_ext = Path(uploaded_file.name).suffix
+            unique_id = uuid.uuid4().hex
+            temp_file = Path(directory) / f"{unique_id}{file_ext}"
+            
+            # Save file
+            with open(temp_file, "wb") as f:
+                f.write(uploaded_file.getbuffer())
+            
+            return str(temp_file)
+        except Exception as e:
+            print(f"Error saving file: {e}")
+            return None
+
+    @staticmethod
+    def save_resume(resume_data, output_path):
+        """Save resume content to file"""
+        try:
+            if output_path.endswith('.docx'):
+                doc = Document()
+                for paragraph in resume_data.split('\n'):
+                    doc.add_paragraph(paragraph)
+                doc.save(output_path)
+            else:
+                with open(output_path, 'w') as f:
+                    f.write(resume_data)
+            return True
+        except Exception as e:
+            print(f"Error saving resume: {e}")
+            return False
+
+    @staticmethod
+    def cleanup_temp_files(directory="temp_uploads"):
+        """Remove temporary files"""
+        try:
+            for file in Path(directory).glob("*"):
+                file.unlink()
+            return True
+        except Exception as e:
+            print(f"Error cleaning files: {e}")
+            return False

utils/logger.py

@@ -0,0 +1,18 @@
+import logging
+
+def setup_logger(name: str = 'ats_optimizer'):
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    
+    return logger
+
+
+# Create a module-level logger instance
+logger = setup_logger()