check

.dockerignore

@@ -0,0 +1,49 @@
+# Virtual environments
+myenv/
+venv/
+env/
+
+# Data directories
+Data/
+data/
+
+# Test directories
+test/
+tests/
+
+# IDE settings
+.vscode/
+.idea/
+
+# Python cache files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.coverage
+htmlcov/
+
+# Logs
+*.log
+logs/
+
+# Local configuration
+.env.local
+.env.development
+.env.test
+
+# Temporary files
+tmp/
+temp/
+
+# Git related
+.git/
+.gitignore
+
+# Docker related
+.docker/
+
+# System files
+.DS_Store
+Thumbs.db

.gitignore

@@ -0,0 +1,63 @@
+# Python
+*__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Django
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+media
+
+# Environment variables
+.env
+**/.env
+
+.env.local
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific files
+.DS_Store
+Thumbs.db
+
+myenv
+*test/

.hfignore

@@ -0,0 +1,20 @@
+# Ignore Python virtual environment
+
+myenv/
+
+# Ignore build directories
+
+__pycache__/
+build/
+dist/
+
+# Ignore sensitive files
+
+**/.env
+
+**/.parquet
+
+secrets.json
+
+migrations/
+Data/

Data/output.json

@@ -0,0 +1,119 @@
+{"total_score": 70.5, "detailed_scores": {"skills_match": 80.0, "experience_relevance": 65.0, "education_relevance": 80, "overall_formatting": 100}, "feedback": {"strengths": ["Strong skills match", "Strong education relevance", "Strong overall formatting"], "improvements": []}, "detailed_feedback": {"skills_match": {"matching_elements": ["Python"], "missing_elements": ["Django", "REST APIs"], "explanation": "The candidate demonstrates proficiency in Python, which is a key requirement. However, the candidate lacks explicit mention of Django and REST APIs, which are crucial for the job description. While FastAPI and Flask are related to REST APIs, they are not a direct substitute for experience with RESTful principles. The other listed skills are not directly relevant to the job description."}, "experience_relevance": {"matching_elements": ["Experience with Python in the context of AI model development.", "Experience in developing systems that require efficient processing."], "missing_elements": ["Experience with Django.", "Experience with REST APIs.", "Experience in general software engineering outside of AI/ML."], "explanation": "The candidate has relevant experience with Python, which is a core requirement for the software engineer role. The experience developing a speech-to-text summarization system indicates an understanding of efficient processing, which can be valuable. However, the experience lacks direct involvement with Django and REST APIs, which are key technologies mentioned in the job description. The role is for a software engineer, and the work experience is primarily focused on AI/ML, so the relevance is moderate."}, "education_relevance": {"matching_elements": ["Strong GPA: 8.46"], "missing_elements": [], "explanation": "Education assessment completed"}, "overall_formatting": {"matching_elements": ["name", "email", "phone"], "missing_elements": [], "explanation": "Format assessment completed"}}}
+{"ats_score": 72.5, "detailed_scores": {"skills_match": 80.0, "experience_relevance": 65.0, "education_relevance": 90, "overall_formatting": 100, "extra_sections": 0.0}, "feedback": {"strengths": ["Strong skills match", "Strong education relevance", "Strong overall formatting"], "improvements": ["Improve extra sections"]}, "detailed_feedback": {"skills_match": {"matching_elements": ["Python"], "missing_elements": ["Django", "REST APIs"], "explanation": "The candidate demonstrates proficiency in Python, which is a core requirement. However, the job description specifically mentions Django and REST APIs, which are not explicitly listed in the candidate's skills. While the candidate has a strong foundation in programming and related technologies, the lack of Django and REST API experience lowers the overall score. Knowledge of frameworks such as FastAPI or Flask may be relevant."}, "experience_relevance": {"matching_elements": ["Python (implied through the use of NLP models and neural network development)", "Experience in developing and improving system performance"], "missing_elements": ["Django", "REST APIs", "Software Engineering experience"], "explanation": "The candidate's experience shows some relevance to the software engineer role. The use of Python for NLP model development and neural networks is a positive indicator. The project focusing on improving system performance is also relevant. However, there is no direct mention of Django or REST APIs, which are key requirements. The internship is relatively short (5 months), and the experience is primarily in research and development rather than software engineering, which lowers the score."}, "education_relevance": {"matching_elements": ["Strong GPA: 8.46", "MTECH (Integrated) in Computer Science and Engineering from Vellore Institute of Technology (VIT) Vellore, India"], "missing_elements": [], "explanation": "Education assessment completed"}, "overall_formatting": {"matching_elements": ["name", "email", "phone"], "missing_elements": [], "explanation": "Format assessment completed"}, "extra_sections": {"matching_elements": [], "missing_elements": ["Awards And Achievements", "Volunteer Experience", "Hobbies And Interests", "Publications", "Conferences And Presentations", "Patents", "Professional Affiliations", "Portfolio Links", "Summary Or Objective"], "explanation": "Additional sections assessment completed"}}}
+
+{
+    "user_id": 12345,
+    "user_name": "John Doe",
+    "similarity": 0.23571285605430603,
+    "ats_score": {
+        "ats_score": 70.5,
+        "detailed_scores": {
+            "skills_match": 80.0,
+            "experience_relevance": 65.0,
+            "education_relevance": 80,
+            "overall_formatting": 100
+        },
+        "feedback": {
+            "strengths": [
+                "Strong skills match",
+                "Strong education relevance",
+                "Strong overall formatting"
+            ],
+            "improvements": []
+        },
+        "detailed_feedback": {
+            "skills_match": {
+                "matching_elements": [
+                    "Python"
+                ],
+                "missing_elements": [
+                    "Django",
+                    "REST APIs"
+                ],
+                "explanation": "The candidate possesses Python skills, which is a core requirement. Django and REST APIs are missing but are crucial for the job. The other skills, while valuable in general software engineering, are not directly relevant to the specific requirements outlined in the job description, hence the score reflects the partial match."
+            },
+            "experience_relevance": {
+                "matching_elements": [
+                    "Developed a speech-to-text summarization system integrating Whisper for transcription and Pegasus for summarization",
+                    "Conducted in-depth research on advanced NLP models such as PEGASUS, BERTsum and BART",
+                    "Built a neural network for handwritten digit classification (MNIST) from scratch, implementing core machine learning concepts like gradient descent and one-hot encoding"
+                ],
+                "missing_elements": [
+                    "Experience with Python",
+                    "Experience with Django",
+                    "Experience with REST APIs",
+                    "Software Engineering specific projects"
+                ],
+                "explanation": "The work experience demonstrates a strong foundation in AI, NLP, and machine learning, which are relevant to software engineering. The intern developed a speech-to-text summarization system and built a neural network, showcasing practical skills. However, the description lacks explicit mention of Python, Django, or REST APIs, which are key requirements for the software engineer role. The experience is relevant but not a direct match for the specific technologies mentioned in the job description. The duration of the internship (Jun 2024 - Oct 2024) is a reasonable length, indicating a solid commitment to the role."
+            },
+            "education_relevance": {
+                "matching_elements": [
+                    "Strong GPA: 8.46"
+                ],
+                "missing_elements": [],
+                "explanation": "Education assessment completed"
+            },
+            "overall_formatting": {
+                "matching_elements": [
+                    "name",
+                    "email",
+                    "phone"
+                ],
+                "missing_elements": [],
+                "explanation": "Format assessment completed"
+            }
+        }
+    },
+    "structured_data": {
+        "name": "Harish KB",
+        "email": "[email protected]",
+        "phone": "8248052926",
+        "skills": [
+            "Python",
+            "Java",
+            "C/C++",
+            "Supervised learning",
+            "unsupervised learning",
+            "NLP",
+            "LLMs",
+            "GitHub",
+            "Docker",
+            "Linux",
+            "AWS",
+            "Hugging Face",
+            "OpenCV",
+            "YOLO",
+            "FastAPI",
+            "Flask",
+            "MongoDB",
+            "Firebase"
+        ],
+        "experience": [
+            {
+                "title": "AI Research and Development Intern (Remote)",
+                "company": "eBramha Techworks Private Limited",
+                "dates": "Jun 2024 - Oct 2024",
+                "description": "- Developed a speech-to-text summarization system integrating Whisper for transcription and Pegasus for summarization, enhancing processing speed and efficiency while significantly reducing overall processing time and improving system performance.\n- Conducted in-depth research on advanced NLP models such as PEGASUS, BERTsum and BART, contributing to the development of effective solutions for tasks like summarization and language understanding.\n- Built a neural network for handwritten digit classification (MNIST) from scratch, implementing core machine learning concepts like gradient descent and one-hot encoding."
+            }
+        ],
+        "education": [
+            {
+                "institution": "Vellore Institute of Technology (VIT), Vellore, India",
+                "degree": "MTECH (Integrated) in Computer Science and Engineering",
+                "dates": "Aug 2022 - July 2027",
+                "gpa": "8.46"
+            }
+        ],
+        "certifications": [
+            "Coursera: Supervised Machine Learning: Regression and Classification",
+            "Coursera: Advanced Learning Algorithms",
+            "Coursera: Generative AI with Large Language Models"
+        ],
+        "areas_of_interest": [
+            "Machine Learning and AI",
+            "Full Stack Development",
+            "Cloud Computing and DevOps Practices"
+        ]
+    },
+    "markdown_format": "# Harish KB\n\n8248052926 | [email protected]\n\n## Education\n\nVellore Institute of Technology (VIT), Vellore, India\nMTECH (Integrated) in Computer Science and Engineering (CGPA: 8.46)\nAug 2022 - July 2027\n\n## Experience\n\n**AI Research and Development Intern (Remote)**\neBramha Techworks Private Limited\nJun 2024 - Oct 2024\n\n*   Developed a speech-to-text summarization system integrating Whisper for transcription and Pegasus for summarization, enhancing processing speed and efficiency while significantly reducing overall processing time and improving system performance.\n*   Conducted in-depth research on advanced NLP models such as PEGASUS, BERTsum and BART, contributing to the development of effective solutions for tasks like summarization and language understanding.\n*   Built a neural network for handwritten digit classification (MNIST) from scratch, implementing core machine learning concepts like gradient descent and one-hot encoding.\n\n## Projects\n\n**VerbiSense: Interactive Document Retrieval System**\nLink\n\n*   Built the VerbiSense backend with FastAPI, optimizing document uploads, query processing, and API performance for real-time interactions with the React frontend.\n*   Integrated Retrieval-Augmented Generation (RAG) for improved document retrieval and response generation.\n*   Applied PyTorch models for advanced NLP tasks like semantic understanding and context-based querying.\n\n**Speech-to-Text Summarization**\n\n*   Developed a Python script that improved audio transcription accuracy by 30% and reduced post-processing time by 35%.\n*   Designed and implemented the frontend interface to provide a seamless, user-friendly experience for individuals interacting with the speech-to-text summarization system.\n\n## Technical Skills\n\n**Languages**: Python, Java, C/C++\n**Machine Learning**: Supervised learning, unsupervised learning, NLP, LLMs\n**Tools**: GitHub, Docker, Linux, AWS, Hugging Face\n**Computer Vision**: OpenCV, YOLO\n**Backend**: FastAPI, Flask, MongoDB, Firebase\n\n## Areas of Interest\n\n*   Machine Learning and AI\n*   Full Stack Development\n*   Cloud Computing and DevOps Practices\n\n## Certifications\n\n*   Coursera: Supervised Machine Learning: Regression and Classification\n*   Coursera: Advanced Learning Algorithms\n*   Coursera: Generative AI with Large Language Models."
+}

Data/output.txt

@@ -0,0 +1,49 @@
+Harish KB
+„ 8248052926
+# [email protected]
+ï Harish KB
+§ HARISH20205
+Education
+Vellore Institute of Technology (VIT)
+Vellore, India
+MTECH (Integrated) in Computer Science and Engineering(CGPA: 8.46)
+Aug 2022– July 2027
+Experience
+AI Research and Development Intern (Remote)
+Jun 2024 – Oct 2024
+eBramha Techworks Private Limited
+• Developed a speech-to-text summarization system integrating Whisper for transcription and Pegasus for
+summarization, enhancing processing speed and efficiency while significantly reducing overall processing
+time and improving system performance.
+• Conducted in-depth research on advanced NLP models such as PEGASUS, BERTsum and BART,
+contributing to the development of effective solutions for tasks like summarization and language
+understanding.
+• Built a neural network for handwritten digit classification (MNIST) from scratch, implementing core
+machine learning concepts like gradient descent and one-hot encoding.
+Projects
+VerbiSense: Interactive Document Retrieval System - Link
+• Built the VerbiSense backend with FastAPI, optimizing document uploads, query processing, and API
+performance for real-time interactions with the React frontend.
+• Integrated Retrieval-Augmented Generation (RAG) for improved document retrieval and response
+generation.
+• Applied PyTorch models for advanced NLP tasks like semantic understanding and context-based querying.
+Speech-to-Text Summarization
+• Developed a Python script that improved audio transcription accuracy by 30% and reduced
+post-processing time by 35%.
+• Designed and implemented the frontend interface to provide a seamless, user-friendly experience for
+individuals interacting with the speech-to-text summarization system.
+Technical Skills
+Languages: Python, Java, C/C++
+Machine Learning: Supervised learning, unsupervised learning, NLP, LLMs
+Tools: GitHub, Docker, Linux, AWS, Hugging Face
+Computer Vision: OpenCV, YOLO
+Backend: FastAPI, Flask, MongoDB, Firebase
+Areas of Interest
+• Machine Learning and AI
+• Full Stack Development
+• Cloud Computing and DevOps Practices
+Certifications
+• Coursera: Supervised Machine Learning: Regression and Classification
+• Coursera: Advanced Learning Algorithms
+• Coursera: Generative AI with Large Language Models
+

Data/outputjson.json

@@ -0,0 +1,7 @@
+{
+    "sections": [
+        {
+            "page_content": ""
+        }
+    ]
+}

Dockerfile

@@ -0,0 +1,48 @@
+# Base image with Python optimized for Hugging Face Spaces
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+ENV PYTHONPATH=/app
+
+# Set working directory
+WORKDIR /app
+
+# Install essential system dependencies including build-essential
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    tesseract-ocr \
+    poppler-utils \
+    build-essential \
+    python3-dev \
+    curl \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy only necessary application code
+COPY app.py /app/
+COPY Process/ /app/Process/
+COPY ResumeATS/ /app/ResumeATS/
+COPY manage.py /app/
+
+# Create a non-root user for security
+RUN adduser --disabled-password --gecos "" appuser
+RUN chown -R appuser:appuser /app
+USER appuser
+
+# Expose the port Hugging Face Spaces will use
+EXPOSE 7860
+
+# Healthcheck to verify the service is running
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:${PORT}/ || exit 1
+
+# Run app.py as required for Hugging Face Spaces
+CMD ["python", "app.py"]

Process/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

Process/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class ApiConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'Process'

Process/ats_parser.py

@@ -0,0 +1,87 @@
+import re
+from .response import get_response  
+from pydantic import BaseModel, TypeAdapter
+import json
+
+class Section:
+    name: str
+    email: str
+    phone: str
+    skills: str
+    experience: str
+    education: str
+    certifications: str
+    areas_of_interest: str
+
+def deep_get(dictionary, keys, default=None):
+    for key in keys:
+        if isinstance(dictionary, dict):
+            dictionary = dictionary.get(key, {})
+        else:
+            return default
+    return dictionary if dictionary != {} else default
+
+
+
+def extract_resume_details(resume: str):
+    print("Innnnnnnnnnnnnnnnnnnnnnnnnnnn")
+    """
+    This function processes a given resume text to:
+    1. Extract structured data into predefined fields.
+    
+
+    Parameters:
+        resume (str): The raw text of the resume.
+
+    Returns:
+        JSON: A JSON containing the structured data in JSON format.
+    """
+
+    system_ins = """Analyze the provided resume and perform the following tasks:
+
+1. Extract the resume's content into a structured format under the following fields:
+
+{
+    "structured_data":{
+        "name": None,
+        "email": None,
+        "github": None,
+        "phone": None,
+        "skills": None,
+        "experience": None,
+        "education": None,
+        "certifications": None,
+        "areas_of_interest": None,
+        "projects": None,
+        "languages": None,
+        "awards_and_achievements": None,
+        "volunteer_experience": None,
+        "hobbies_and_interests": None,
+        "publications": None,
+        "conferences_and_presentations": None,
+        "patents": None,
+        "professional_affiliations": None,
+        "portfolio_links": None,
+        "summary_or_objective": None
+        }
+}
+
+- Provide this output in JSON format under the key "structured_data".
+- If a field is missing or cannot be determined, set its value to None.
+"""
+    try:
+        combined_output = get_response(prompt=resume, task=system_ins)
+        print("Before parsing st dataa to JSON",combined_output)
+        
+        result = json.loads(combined_output)
+        print("after st data json",combined_output)
+
+        structured_data = result["structured_data"]
+        print(structured_data)
+
+        return structured_data
+    except:
+        return {"structured_data":"Failed to Get Due to Improper Json Data"}
+# resume = "Harish KB 8248052926 # [email protected] i Harish KB HARISH20205 Education Vellore Institute of Technology (VIT) Vellore, India MTECH (Integrated) in Computer Science and Engineering(CGPA: 8.46) Aug 2022 July 2027 Experience AI Research and Development Intern (Remote) Jun 2024 Oct 2024 eBramha Techworks Private Limited - Developed a speech-to-text summarization system integrating Whisper for transcription and Pegasus for summarization, enhancing processing speed and efficiency while significantly reducing overall processing time and improving system performance. - Conducted in-depth research on advanced NLP models such as PEGASUS, BERTsum and BART, contributing to the development of effective solutions for tasks like summarization and language understanding. - Built a neural network for handwritten digit classification (MNIST) from scratch, implementing core machine learning concepts like gradient descent and one-hot encoding. Projects VerbiSense: Interactive Document Retrieval System - Link - Built the VerbiSense backend with FastAPI, optimizing document uploads, query processing, and API performance for real-time interactions with the React frontend. - Integrated Retrieval-Augmented Generation (RAG) for improved document retrieval and response generation. - Applied PyTorch models for advanced NLP tasks like semantic understanding and context-based querying. Speech-to-Text Summarization - Developed a Python script that improved audio transcription accuracy by 30% and reduced post-processing time by 35%. - Designed and implemented the frontend interface to provide a seamless, user-friendly experience for individuals interacting with the speech-to-text summarization system. Technical Skills Languages: Python, Java, C/C++ Machine Learning: Supervised learning, unsupervised learning, NLP, LLMs Tools: GitHub, Docker, Linux, AWS, Hugging Face Computer Vision: OpenCV, YOLO Backend: FastAPI, Flask, MongoDB, Firebase Areas of Interest - Machine Learning and AI - Full Stack Development - Cloud Computing and DevOps Practices Certifications - Coursera: Supervised Machine Learning: Regression and Classification - Coursera: Advanced Learning Algorithms - Coursera: Generative AI with Large Language Models."
+
+# print(extract_resume_details(resume))

Process/change.py

@@ -0,0 +1,54 @@
+from django.http import JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+import json
+import logging
+import concurrent.futures
+
+from .response import get_response
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+@csrf_exempt
+def process_change(request):
+    if request.method == "POST":
+        try:
+            # Parse JSON only once
+            data = json.loads(request.body)
+
+            user_id = data.get('user_id')
+            prompt = data.get("prompt")
+            content = data.get('content')
+            section = data.get("section")
+            job_description = data.get('job_description')
+            
+            if not all([user_id, prompt, content]):
+                return JsonResponse({'error': 'Missing required fields'}, status=400)
+            
+            # Customize processing approach based on section
+            section_specific_instruction = ""
+            if section == "skills" or section == "experience" or section == "projects":
+                section_specific_instruction = "Format achievements using the X-Y-Z method (e.g., 'Accomplished X as measured by Y, by doing Z'). Provide at least one compelling example that demonstrates measurable impact."
+            else:
+                section_specific_instruction = "Incorporate relevant keywords from the job description while avoiding generic buzzwords. Focus on specificity and concrete details that align with ATS screening requirements."
+            
+            combined_prompt = f"Content: {content}\nJob Description: {job_description}\nTask: {prompt}"
+            
+            system_instruction = """As an ATS resume optimizer, modify the content to match the job requirements while preserving truthfulness. Use the X-Y-Z method to quantify achievements where possible (e.g., "Accomplished X as measured by Y, by doing Z"). Format your response as a clean text without any prefixes or explanations. Do not include any JSON formatting in your actual content modification."""
+            
+            # Combine system_instruction with section_specific_instruction
+            combined_system_instruction = f"{system_instruction} {section_specific_instruction}"
+            
+            modified_content = get_response(combined_prompt, combined_system_instruction)
+            
+            return JsonResponse({
+                'user_id': user_id,
+                'modified_content': modified_content
+            }, status=200)
+            
+        except json.JSONDecodeError:
+            return JsonResponse({'error': 'Invalid JSON format'}, status=400)
+        except Exception as e:
+            logger.error(f"Error in process_change: {str(e)}")
+            return JsonResponse({'error': 'Processing error'}, status=500)
+    else:
+        return JsonResponse({'message': 'Only POST requests are allowed'}, status=405)

Process/extract.py

@@ -0,0 +1,27 @@
+import fitz  # PyMuPDF
+import pytesseract
+from PIL import Image
+import io
+
+def extract_text_from_pdf(file_path):
+    text = ""
+    doc = fitz.open(file_path)
+
+    for page_num in range(len(doc)):
+        page = doc.load_page(page_num)
+        # Try to extract text
+        page_text = page.get_text()
+        
+        if page_text.strip():  # If text is found
+            text += page_text
+        else:  # If no text, use OCR
+            pix = page.get_pixmap()
+            img = Image.open(io.BytesIO(pix.tobytes("png")))
+            ocr_text = pytesseract.image_to_string(img)
+            text += ocr_text
+
+    return text
+
+# file_path = "../Data/resumen.pdf"
+# text = extract_text_from_pdf(file_path)
+# print(text)

Process/migrations/0001_initial.py

@@ -0,0 +1,24 @@
+# Generated by Django 5.1.5 on 2025-02-05 14:15
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='EndPoint',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('user_name', models.TextField()),
+                ('user_id', models.IntegerField()),
+                ('resume', models.TextField()),
+                ('prompt', models.TextField()),
+            ],
+        ),
+    ]

Process/migrations/0002_endpoint_time.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.1.5 on 2025-02-05 14:25
+
+import django.utils.timezone
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('Process', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='endpoint',
+            name='time',
+            field=models.DateTimeField(auto_now_add=True, default=django.utils.timezone.now),
+            preserve_default=False,
+        ),
+    ]

Process/migrations/0003_rename_prompt_endpoint_job_description.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-02-13 14:40
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('Process', '0002_endpoint_time'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='endpoint',
+            old_name='prompt',
+            new_name='job_description',
+        ),
+    ]

Process/models.py

@@ -0,0 +1,19 @@
+from django.db import models
+
+# Create your models here.
+ 
+class EndPoint(models.Model):
+    user_id = models.IntegerField()
+    resume = models.TextField()
+    job_description = models.TextField()
+    time = models.DateTimeField(auto_now_add=True)    
+
+    def __str__(self):
+        return {
+            'user_id':self.user_id,
+            'resume':self.resume,
+            'job_description':self.job_description,
+            'time':self.time
+        }
+
+    

Process/output.json

@@ -0,0 +1,121 @@
+{
+  "user_id": 12345,
+  "similarity": 0.23571285605430603,
+  "ats_score": {
+    "ats_score": 68.5,
+    "detailed_scores": {
+      "skills_match": 80.0,
+      "experience_relevance": 65.0,
+      "education_relevance": 70,
+      "overall_formatting": 100
+    },
+    "feedback": {
+      "strengths": ["Strong skills match", "Strong overall formatting"],
+      "improvements": []
+    },
+    "detailed_feedback": {
+      "skills_match": {
+        "matching_elements": ["Python"],
+        "missing_elements": ["Django", "REST APIs"],
+        "explanation": "The candidate possesses Python skills, which is a core requirement. However, they lack explicit mention of Django and REST APIs, which are essential for the job. Other skills, while valuable in general software engineering, are not directly relevant to the specified job description focusing on Python, Django, and REST APIs."
+      },
+      "experience_relevance": {
+        "matching_elements": [
+          "Developed a speech-to-text summarization system integrating Whisper for transcription and Pegasus for summarization",
+          "Conducted in-depth research on advanced NLP models such as PEGASUS, BERTsum and BART"
+        ],
+        "missing_elements": [
+          "Experience with Django framework",
+          "Experience with REST APIs",
+          "Software engineering experience outside of internship"
+        ],
+        "explanation": "The work experience demonstrates some relevance to software engineering through the development of a speech-to-text summarization system and research on NLP models. These indicate programming and problem-solving skills, which are valuable in software engineering. The implementation of a neural network from scratch further highlights programming capabilities. However, the experience is limited to an internship, and there's no explicit mention of Python, Django, or REST APIs, which are key requirements for the target job description. The score reflects the partial relevance due to general programming and model development experience, but the lack of specific skills and professional experience lowers the score."
+      },
+      "education_relevance": {
+        "matching_elements": [],
+        "missing_elements": [],
+        "explanation": "Education assessment completed"
+      },
+      "overall_formatting": {
+        "matching_elements": ["name", "email", "phone"],
+        "missing_elements": [],
+        "explanation": "Format assessment completed"
+      }
+    }
+  },
+  "structured_data": {
+    "name": "Harish KB",
+    "email": "[email protected]",
+    "phone": "8248052926",
+    "skills": [
+      "Python",
+      "Java",
+      "C/C++",
+      "Supervised learning",
+      "Unsupervised learning",
+      "NLP",
+      "LLMs",
+      "GitHub",
+      "Docker",
+      "Linux",
+      "AWS",
+      "Hugging Face",
+      "OpenCV",
+      "YOLO",
+      "FastAPI",
+      "Flask",
+      "MongoDB",
+      "Firebase"
+    ],
+    "experience": [
+      {
+        "title": "AI Research and Development Intern (Remote)",
+        "company": "eBramha Techworks Private Limited",
+        "start_date": "Jun 2024",
+        "end_date": "Oct 2024",
+        "description": "- Developed a speech-to-text summarization system integrating Whisper for transcription and Pegasus for summarization, enhancing processing speed and efficiency while significantly reducing overall processing time and improving system performance.\n- Conducted in-depth research on advanced NLP models such as PEGASUS, BERTsum and BART, contributing to the development of effective solutions for tasks like summarization and language understanding.\n- Built a neural network for handwritten digit classification (MNIST) from scratch, implementing core machine learning concepts like gradient descent and one-hot encoding."
+      }
+    ],
+    "education": [
+      {
+        "institution": "Vellore Institute of Technology (VIT)",
+        "location": "Vellore, India",
+        "degree": "MTECH (Integrated) in Computer Science and Engineering",
+        "graduation_date": "July 2027",
+        "start_date": "Aug 2022",
+        "cgpa": "8.46"
+      }
+    ],
+    "certifications": [
+      "Coursera: Supervised Machine Learning: Regression and Classification",
+      "Coursera: Advanced Learning Algorithms",
+      "Coursera: Generative AI with Large Language Models"
+    ],
+    "areas_of_interest": [
+      "Machine Learning and AI",
+      "Full Stack Development",
+      "Cloud Computing and DevOps Practices"
+    ],
+    "projects": [
+      {
+        "name": "VerbiSense: Interactive Document Retrieval System",
+        "description": "- Built the VerbiSense backend with FastAPI, optimizing document uploads, query processing, and API performance for real-time interactions with the React frontend.\n- Integrated Retrieval-Augmented Generation (RAG) for improved document retrieval and response generation.\n- Applied PyTorch models for advanced NLP tasks like semantic understanding and context-based querying."
+      },
+      {
+        "name": "Speech-to-Text Summarization",
+        "description": "- Developed a Python script that improved audio transcription accuracy by 30% and reduced post-processing time by 35%.\n- Designed and implemented the frontend interface to provide a seamless, user-friendly experience for individuals interacting with the speech-to-text summarization system."
+      }
+    ],
+    "languages": ["Python", "Java", "C/C++"],
+    "awards_and_achievements": null,
+    "volunteer_experience": null,
+    "hobbies_and_interests": null,
+    "publications": null,
+    "conferences_and_presentations": null,
+    "patents": null,
+    "professional_affiliations": null,
+    "portfolio_links": null,
+    "summary_or_objective": null
+  },
+  "markdown_format": "# Harish KB\n\n8248052926  | [email protected]\n\n## Education\n\nVellore Institute of Technology (VIT), Vellore, India\nMTECH (Integrated) in Computer Science and Engineering (CGPA: 8.46)\nAug 2022 - July 2027\n\n## Experience\n\n**AI Research and Development Intern (Remote)**\neBramha Techworks Private Limited\nJun 2024 - Oct 2024\n\n*   Developed a speech-to-text summarization system integrating Whisper for transcription and Pegasus for summarization, enhancing processing speed and efficiency while significantly reducing overall processing time and improving system performance.\n*   Conducted in-depth research on advanced NLP models such as PEGASUS, BERTsum and BART, contributing to the development of effective solutions for tasks like summarization and language understanding.\n*   Built a neural network for handwritten digit classification (MNIST) from scratch, implementing core machine learning concepts like gradient descent and one-hot encoding.\n\n## Projects\n\n**VerbiSense: Interactive Document Retrieval System**\n\n*   Built the VerbiSense backend with FastAPI, optimizing document uploads, query processing, and API performance for real-time interactions with the React frontend.\n*   Integrated Retrieval-Augmented Generation (RAG) for improved document retrieval and response generation.\n*   Applied PyTorch models for advanced NLP tasks like semantic understanding and context-based querying.\n\n**Speech-to-Text Summarization**\n\n*   Developed a Python script that improved audio transcription accuracy by 30% and reduced post-processing time by 35%.\n*   Designed and implemented the frontend interface to provide a seamless, user-friendly experience for individuals interacting with the speech-to-text summarization system.\n\n## Technical Skills\n\n**Languages:** Python, Java, C/C++\n**Machine Learning:** Supervised learning, unsupervised learning, NLP, LLMs\n**Tools:** GitHub, Docker, Linux, AWS, Hugging Face\n**Computer Vision:** OpenCV, YOLO\n**Backend:** FastAPI, Flask, MongoDB, Firebase\n\n## Areas of Interest\n\n*   Machine Learning and AI\n*   Full Stack Development\n*   Cloud Computing and DevOps Practices\n\n## Certifications\n\n*   Coursera: Supervised Machine Learning: Regression and Classification\n*   Coursera: Advanced Learning Algorithms\n*   Coursera: Generative AI with Large Language Models."
+}

Process/response.py

@@ -0,0 +1,24 @@
+import os
+from dotenv import load_dotenv
+
+from google import genai
+from google.genai import types
+
+load_dotenv()
+
+
+
+sys_instruct="Provide the output in JSON format where the key is the topic and the value is a list of relevant contents. Ensure the response is clear, user friendly, structured."
+def get_response(prompt,task):
+    client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
+
+    response = client.models.generate_content(
+        model="gemini-2.0-flash",
+        config=types.GenerateContentConfig(
+            system_instruction=task+sys_instruct,response_mime_type='application/json',temperature=0.6),
+        contents=prompt
+    )
+    # print(response.text)
+    return response.text
+
+# get_response("What is AI?","explain the given prompt")

Process/serializers.py

@@ -0,0 +1,8 @@
+from rest_framework import serializers
+from .models import EndPoint
+
+
+class EndPointSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EndPoint
+        fields = ['id','user_id','resume','prompt','time']

Process/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

Process/urls.py

@@ -0,0 +1,10 @@
+from django.urls import path
+from . import views
+from .change import process_change
+
+urlpatterns = [
+    path('process_resume/', views.process_resume, name='handle_request'),
+    path('process_change/', process_change, name="handle_change"), 
+    path('verify_api/', views.verify_api, name='verify_api'),
+]
+

Process/utils.py

@@ -0,0 +1,271 @@
+import json
+import concurrent.futures
+import logging
+from typing import Dict, List, Optional, Union
+from .response import get_response
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+SYSTEM_INSTRUCTION = """
+Provide responses in this exact JSON format:
+{
+    "score": <number 0-10>,
+    "matching_elements": [<list of matching items>],
+    "missing_elements": [<list of recommended items>],
+    "explanation": "<explanation in 10-15 words>"
+}
+Ensure the score is always a number between 0-10.
+"""
+
+class ATSResumeParser:
+    def __init__(self):
+        self.score_weights = {
+            'skills_match': 30,
+            'experience_relevance': 25,
+            'education_relevance': 10,
+            'overall_formatting': 15,
+            'keyword_optimization': 10,
+            'extra_sections': 10
+        }
+        self.total_weight = sum(self.score_weights.values())
+
+    def _parse_gemini_response(self, response_text: str) -> Dict:
+        """Parse the response from Gemini API with caching for better performance"""
+        try:
+            response = json.loads(response_text)
+            return {
+                'score': float(response['score']),
+                'matching': response.get('matching_elements', []),
+                'missing': response.get('missing_elements', []),
+                'explanation': response.get('explanation', '')
+            }
+        except (json.JSONDecodeError, KeyError, ValueError):
+            return {'score': 5.0, 'matching': [], 'missing': [], 'explanation': ''}
+
+    def _score_skills(self, skills: List[str], job_description: Optional[str]) -> Dict:
+        print("skills:",skills)
+        """Score skills with optimized processing"""
+        if not skills:
+            return {'score': 0, 'matching': [], 'missing': [], 'explanation': 'No skills provided'}
+            
+        base_score = 70  
+        
+        skills_length = len(skills)
+        if skills_length >= 5:
+            base_score += 10
+        if skills_length >= 10:
+            base_score += 10
+            
+        if not job_description:
+            return {'score': base_score, 'matching': skills, 'missing': [], 'explanation': 'No job description provided'}
+
+        prompt = f"Skills: {','.join(skills[:20])}. Job description: {job_description[:500]}. Rate match."
+        
+        response = self._parse_gemini_response(
+            get_response(prompt, SYSTEM_INSTRUCTION)
+        )
+        print("complted skills:",response)
+        return {
+            'score': (base_score + (response['score'] * 10)) / 2,
+            'matching': response['matching'],
+            'missing': response['missing'],
+            'explanation': response['explanation']
+        }
+
+    def _score_experience(self, experience: List[Dict], job_description: Optional[str]) -> Dict:
+        """Score experience with optimized processing"""
+        print("experience:",experience)
+        if not experience:
+            return {'score': 0, 'matching': [], 'missing': [], 'explanation': 'No experience provided'}
+            
+        base_score = 60
+        
+        required_keys = {'title', 'company', 'description'}
+        improvement_keywords = {'increased', 'decreased', 'improved', '%', 'reduced'}
+        
+        for exp in experience:
+            if required_keys.issubset(exp.keys()):
+                base_score += 10
+                
+            description = exp.get('description', '')
+            if description and any(keyword in description for keyword in improvement_keywords):
+                base_score += 5
+                
+        if not job_description:
+            return {'score': base_score, 'matching': [], 'missing': [], 'explanation': 'No job description provided'}
+        
+        simplified_exp = [{'title': e.get('title', ''), 'description': e.get('description', '')[:100]} 
+                          for e in experience[:3]]
+        
+        prompt = f"Experience: {json.dumps(simplified_exp)}. Job description: {job_description[:500]}. Rate match."
+        
+        response = self._parse_gemini_response(
+            get_response(prompt, SYSTEM_INSTRUCTION)
+        )
+        print("completed experience:",response)
+        return {
+            'score': (base_score + (response['score'] * 10)) / 2,
+            'matching': response['matching'],
+            'missing': response['missing'],
+            'explanation': response['explanation']
+        }
+
+    def _score_education(self, education: List[Dict]) -> Dict:
+        """Score education with optimized processing"""
+        if not education:
+            return {'score': 0, 'matching': [], 'missing': [], 'explanation': 'No education provided'}
+            
+        score = 70
+        matching = []
+        
+        required_keys = {'institution', 'degree', 'start_date', 'end_date'}
+        
+        for edu in education:
+            gpa = edu.get('gpa')
+            if gpa and float(gpa) > 3.0:
+                score += 10
+                matching.append(f"Strong GPA: {gpa}")
+                
+            if required_keys.issubset(edu.keys()):
+                score += 10
+                matching.append(f"{edu.get('degree', '')} from {edu.get('institution', '')}")
+                
+        return {
+            'score': min(100, score),
+            'matching': matching,
+            'missing': [],
+            'explanation': 'Education assessment completed'
+        }
+
+    def _score_formatting(self, structured_data: Dict) -> Dict:
+        """Score formatting with optimized processing"""
+        score = 100
+        
+        contact_fields = ('name', 'email', 'phone')
+        essential_sections = ('skills', 'experience', 'education')
+        
+        structured_keys = set(structured_data.keys())
+        
+        missing_contacts = [field for field in contact_fields if field not in structured_keys]
+        if missing_contacts:
+            score -= 20
+            
+        missing_sections = [section for section in essential_sections if section not in structured_keys]
+        missing_penalty = 15 * len(missing_sections)
+        if missing_sections:
+            score -= missing_penalty
+                
+        return {
+            'score': max(0, score),
+            'matching': [field for field in contact_fields if field in structured_keys],
+            'missing': missing_contacts + missing_sections,
+            'explanation': 'Format assessment completed'
+        }
+
+    def _score_extra(self, structured_data: Dict) -> Dict:
+        """Score extra sections with optimized processing"""
+        extra_sections = {
+            "awards_and_achievements": 15,
+            "volunteer_experience": 10,
+            "hobbies_and_interests": 5,
+            "publications": 15,
+            "conferences_and_presentations": 10,
+            "patents": 15,
+            "professional_affiliations": 10,
+            "portfolio_links": 10,
+            "summary_or_objective": 10
+        }
+        
+        total_possible = sum(extra_sections.values())
+        
+        structured_keys = set(structured_data.keys())
+        
+        score = 0
+        matching = []
+        missing = []
+        
+        for section, weight in extra_sections.items():
+            if section in structured_keys and structured_data.get(section):
+                score += weight
+                matching.append(section.replace('_', ' ').title())
+            else:
+                missing.append(section.replace('_', ' ').title())
+        
+        normalized_score = (score * 100) // total_possible if total_possible > 0 else 0
+        
+        return {
+            'score': normalized_score,
+            'matching': matching,
+            'missing': missing,
+            'explanation': 'Additional sections assessment completed'
+        }
+
+    def parse_and_score(self, structured_data: Dict, job_description: Optional[str] = None) -> Dict:
+        """Parse and score resume with parallel processing"""
+        scores = {}
+        feedback = {'strengths': [], 'improvements': []}
+        detailed_feedback = {}
+        
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            # Define tasks to run in parallel
+            tasks = {
+                'skills_match': executor.submit(self._score_skills, structured_data.get('skills', []), job_description),
+                'experience_relevance': executor.submit(self._score_experience, structured_data.get('experience', []), job_description),
+                'education_relevance': executor.submit(self._score_education, structured_data.get('education', [])),
+                'overall_formatting': executor.submit(self._score_formatting, structured_data),
+                'extra_sections': executor.submit(self._score_extra, structured_data)
+            }
+            
+            total_score = 0
+            for category, future in tasks.items():
+                result = future.result()
+                
+                scores[category] = result['score']
+                
+                weight = self.score_weights[category] / 100
+                total_score += result['score'] * weight
+                
+                detailed_feedback[category] = {
+                    'matching_elements': result['matching'],
+                    'missing_elements': result['missing'],
+                    'explanation': result['explanation']
+                }
+                
+                if result['score'] >= 80:
+                    feedback['strengths'].append(f"Strong {category.replace('_', ' ')}")
+                elif result['score'] < 60:
+                    feedback['improvements'].append(f"Improve {category.replace('_', ' ')}")
+        
+        return {
+            'total_score': round(total_score, 2),
+            'detailed_scores': scores,
+            'feedback': feedback,
+            'detailed_feedback': detailed_feedback
+        }
+
+def generate_ats_score(structured_data: Union[Dict, str], job_des_text: Optional[str] = None) -> Dict:
+    """Generate ATS score with optimized processing"""
+    try:
+        print("check",structured_data)
+        if not structured_data:
+            return {"error": "No resume data provided"}
+            
+        if isinstance(structured_data, str):
+            try:
+                structured_data = json.loads(structured_data)
+            except json.JSONDecodeError:
+                return {"error": "Invalid JSON format in resume data"}
+        
+        parser = ATSResumeParser()
+        result = parser.parse_and_score(structured_data, job_des_text)
+        
+        return {
+            'ats_score': result['total_score'],
+            'detailed_scores': result['detailed_scores'],
+            'feedback': result['feedback'],
+            'detailed_feedback': result['detailed_feedback']
+        }
+        
+    except Exception as e:
+        return {"error": f"An error occurred: {str(e)}"}

Process/views.py

@@ -0,0 +1,74 @@
+import logging
+from django.http import JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+import json
+from transformers import AutoTokenizer, AutoModel
+import torch
+import os
+
+from .ats_parser import extract_resume_details
+from .utils import generate_ats_score
+from .response import get_response
+from .extract import extract_text_from_pdf
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+model_name = "sentence-transformers/all-MiniLM-L6-v2"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModel.from_pretrained(model_name)
+
+def get_embeddings(texts):
+    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
+    with torch.no_grad():
+        model_output = model(**inputs)
+    embeddings = model_output.last_hidden_state.mean(dim=1)
+    return embeddings
+
+def calculate_similarity(job_description, resume_text):
+    jd_embedding = get_embeddings([job_description])
+    resume_embedding = get_embeddings([resume_text])
+
+    jd_embedding = jd_embedding / jd_embedding.norm(dim=1, keepdim=True)
+    resume_embedding = resume_embedding / resume_embedding.norm(dim=1, keepdim=True)
+    similarity = torch.mm(jd_embedding, resume_embedding.T).item()
+    return similarity
+
+@csrf_exempt
+def process_resume(request):
+    if request.method == 'POST':
+        try:
+            data = json.loads(request.body)
+
+            user_id = data.get('user_id')
+            resume = data.get('resume')
+            job_description = data.get('job_description')
+            logger.info(f"Received data for user_id: {user_id}")
+
+            similarity = calculate_similarity(job_description, resume)
+            logger.info("Similarity calculation completed")
+
+            st_data = extract_resume_details(resume)
+            logger.info("Resume details extraction completed")
+
+            ats_score = generate_ats_score(st_data, job_description)
+            logger.info("ATS score generation completed")
+
+            response_data = {
+                'user_id': user_id,
+                'similarity': similarity,
+                'ats_score': ats_score,
+                'structured_data': st_data
+            }
+            return JsonResponse(response_data, status=200)
+        except json.JSONDecodeError:
+            logger.error("Invalid JSON received")
+            return JsonResponse({'error': 'Invalid JSON'}, status=400)
+    else:
+        return JsonResponse({'message': 'Only POST requests are allowed'}, status=405)
+
+def verify_api(request):
+    if request.method == 'GET':
+        return JsonResponse({'message': 'yaay working-GET '}, status=200)
+    else:
+        return JsonResponse({'error': 'Only GET requests are allowed'}, status=405)

ResumeATS/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for ResumeATS project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.1/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'ResumeATS.settings')
+
+application = get_asgi_application()

ResumeATS/settings.py

@@ -0,0 +1,127 @@
+"""
+Django settings for ResumeATS project.
+
+Generated by 'django-admin startproject' using Django 5.1.5.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.1/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/5.1/ref/settings/
+"""
+
+from pathlib import Path
+from dotenv import load_dotenv
+import os
+load_dotenv()
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/5.1/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = os.getenv("SECRET_KEY")
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = []
+
+
+# Application definition
+
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'rest_framework',
+    'Process',
+]
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'ResumeATS.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = 'ResumeATS.wsgi.application'
+
+
+# Database
+# https://docs.djangoproject.com/en/5.1/ref/settings/#databases
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+
+# Password validation
+# https://docs.djangoproject.com/en/5.1/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/5.1/topics/i18n/
+
+LANGUAGE_CODE = 'en-us'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/5.1/howto/static-files/
+
+STATIC_URL = 'static/'
+
+# Default primary key field type
+# https://docs.djangoproject.com/en/5.1/ref/settings/#default-auto-field
+
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

ResumeATS/urls.py

@@ -0,0 +1,22 @@
+"""
+URL configuration for ResumeATS project.
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/5.1/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  path('', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
+Including another URLconf
+    1. Import the include() function: from django.urls import include, path
+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
+"""
+from django.contrib import admin
+from django.urls import path, include
+
+urlpatterns = [
+    path('', include('Process.urls')),
+]

ResumeATS/wsgi.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for ResumeATS project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.1/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'ResumeATS.settings')
+
+application = get_wsgi_application()

app.py

@@ -0,0 +1,26 @@
+# This is a bridging file for Hugging Face Spaces
+# It ensures that when the container starts, your Django app will run correctly
+
+import os
+import sys
+import subprocess
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+if __name__ == "__main__":
+    # Make sure we're using the correct port
+    port = os.environ.get("PORT", "7860")
+    logger.info(f"Starting Django server on port {port}")
+    
+    try:
+        # Start the Django development server
+        # For better production deployment, consider using gunicorn
+        subprocess.run(
+            ["python", "manage.py", "runserver", f"0.0.0.0:{port}"],
+            check=True
+        )
+    except Exception as e:
+        logger.error(f"Error starting Django server: {e}")
+        sys.exit(1)

deploy.txt

@@ -0,0 +1 @@
+sudo apt-get install tesseract-ocr

manage.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'ResumeATS.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -0,0 +1,35 @@
+# Core dependencies
+Django==5.1.5
+djangorestframework==3.15.2
+python-dotenv==1.0.1
+numpy==2.2.2
+pandas==2.2.3
+scikit-learn==1.6.1
+pillow==11.0.0
+tqdm==4.67.1
+requests==2.32.3
+
+# PDF processing
+pdfplumber==0.11.5
+pdf2docx==0.5.8
+PyMuPDF==1.25.2
+pytesseract==0.3.13
+python-docx==1.1.2
+pdfminer.six==20231228
+
+# NLP & AI
+google-generativeai==0.8.4
+transformers==4.48.2
+nltk==3.9.1
+
+# Image Processing
+opencv-python-headless==4.11.0.86
+
+# File handling and data formats
+pyarrow==19.0.1
+fsspec==2024.12.0
+filelock==3.17.0
+
+# Utilities
+regex==2024.11.6
+markdown2==2.5.3