skills missing elements

Process/ats_parser.py

@@ -1,6 +1,6 @@
 import re
 import logging
-from .response import get_response  
+from .response import get_response
 from pydantic import BaseModel, TypeAdapter
 import json
 import traceback
@@ -8,6 +8,7 @@ import traceback
 # Set up logging
 logger = logging.getLogger(__name__)
 
+
 class Section:
     name: str
     email: str
@@ -18,6 +19,7 @@ class Section:
     certifications: str
     areas_of_interest: str
 
+
 def deep_get(dictionary, keys, default=None):
     logger.debug(f"Accessing deep keys {keys} in dictionary")
     try:
@@ -32,6 +34,7 @@ def deep_get(dictionary, keys, default=None):
         logger.error(f"Error in deep_get function: {e}")
         return default
 
+
 def extract_resume_details(resume: str):
     logger.info("Starting resume details extraction")
     """
@@ -82,7 +85,7 @@ def extract_resume_details(resume: str):
         logger.info("Sending resume to get_response function")
         combined_output = get_response(prompt=resume, task=system_ins)
         logger.debug("Raw response received from get_response")
-        
+
         logger.info("Attempting to parse response to JSON")
         result = json.loads(combined_output)
         logger.debug("Successfully parsed response to JSON")

Process/extract.py

@@ -4,18 +4,19 @@ from PIL import Image
 import io
 import requests
 
+
 def extract_text_from_pdf(file_path_or_url):
     text = ""
-    
+
     # Check if the file_path_or_url is a URL
-    if file_path_or_url.startswith(('http://', 'https://')):
+    if file_path_or_url.startswith(("http://", "https://")):
         # Download the PDF file from URL
         response = requests.get(file_path_or_url)
         if response.status_code != 200:
             raise Exception(f"Failed to download the file: {response.status_code}")
-        
+
         # Open the PDF from the downloaded bytes
-        doc = fitz.open(stream=io.BytesIO(response.content), filetype="pdf")
+        doc = fitz.open(stream=io.BytesIO(response.content), filetype="pdf")a
     else:
         # Open the PDF from a local file path
         doc = fitz.open(file_path_or_url)
@@ -24,7 +25,7 @@ def extract_text_from_pdf(file_path_or_url):
         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
@@ -35,6 +36,7 @@ def extract_text_from_pdf(file_path_or_url):
 
     return text
 
+
 # Example usage with Firebase URL
 # firebase_url = "https://firebasestorage.googleapis.com/v0/b/resumeats-50ccf.firebasestorage.app/o/uploads%2Fsanthoshrajan776%40gmail.com%2FSanthoshNatarajan_InternshalaResume%20(1).pdf?alt=media&token=f11f9601-6550-4e64-bba6-a2b699a148af"
 # text = extract_text_from_pdf(firebase_url)

Process/models.py

@@ -1,19 +1,18 @@
 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)    
+    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
+            "user_id": self.user_id,
+            "resume": self.resume,
+            "job_description": self.job_description,
+            "time": self.time,
         }
-
-    

Process/response.py

@@ -7,18 +7,23 @@ 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."
 
-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):
+
+def get_response(prompt, task, temperature=0.75):
     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
+            system_instruction=task + sys_instruct,
+            response_mime_type="application/json",
+            temperature=temperature,
+        ),
+        contents=prompt,
     )
     # print(response.text)
     return response.text
 
-# get_response("What is AI?","explain the given prompt")
+
+# get_response("What is AI?","explain the given prompt")

Process/urls.py

@@ -3,9 +3,8 @@ from . import views
 from .change import process_change
 
 urlpatterns = [
-    path("",views.home,name="welcome"),
-    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'),
+    path("", views.home, name="welcome"),
+    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

@@ -19,16 +19,17 @@ Provide responses in this exact JSON format:
 Ensure the score is always a number between 0-10.
 """
 
+
 class ATSResumeParser:
     def __init__(self):
         logger.info("Initializing ATSResumeParser")
         self.score_weights = {
-            'skills_match': 30,
-            'experience_relevance': 25,
-            'education_relevance': 10,
-            'overall_formatting': 15,
-            'keyword_optimization': 10,
-            'extra_sections': 10
+            "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())
         logger.debug(f"Score weights configured with total weight: {self.total_weight}")
@@ -39,136 +40,174 @@ class ATSResumeParser:
             logger.debug("Parsing Gemini API response")
             response = json.loads(response_text)
             result = {
-                'score': float(response['score']),
-                'matching': response.get('matching_elements', []),
-                'missing': response.get('missing_elements', []),
-                'explanation': response.get('explanation', '')
+                "score": float(response["score"]),
+                "matching": response.get("matching_elements", []),
+                "missing": response.get("missing_elements", []),
+                "explanation": response.get("explanation", ""),
             }
             logger.debug(f"Successfully parsed response with score: {result['score']}")
             return result
         except (json.JSONDecodeError, KeyError, ValueError) as e:
             logger.error(f"Error parsing Gemini response: {e}")
             logger.debug(f"Failed response content: {response_text}")
-            return {'score': 5.0, 'matching': [], 'missing': [], 'explanation': ''}
+            return {"score": 5.0, "matching": [], "missing": [], "explanation": ""}
         except Exception as e:
             logger.error(f"Unexpected error parsing Gemini response: {e}")
             logger.debug(traceback.format_exc())
-            return {'score': 5.0, 'matching': [], 'missing': [], 'explanation': ''}
+            return {"score": 5.0, "matching": [], "missing": [], "explanation": ""}
 
     def _score_skills(self, skills: List[str], job_description: Optional[str]) -> Dict:
         """Score skills with optimized processing"""
         if not skills:
-            return {'score': 0, 'matching': [], 'missing': [], 'explanation': 'No skills provided'}
-            
-        base_score = 70  
-        
+            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'}
+            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)
-        )
+        prompt = f"""Skills: {','.join(skills[:20])}. 
+    Job description: {job_description[:500]}. 
+    Evaluate the skills match against this job description. 
+    In the 'matching_elements' list, include only skills that directly match the job requirements.
+    In the 'missing_elements' list, include ONLY specific missing skills from the job description (no paragraphs or lengthy text).
+    Rate the overall match on a scale of 0-10."""
+
+        response = self._parse_gemini_response(get_response(prompt, SYSTEM_INSTRUCTION))
         return {
-            'score': (base_score + (response['score'] * 10)) / 2,
-            'matching': response['matching'],
-            'missing': response['missing'],
-            'explanation': response['explanation']
+            "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:
+    def _score_experience(
+        self, experience: List[Dict], job_description: Optional[str]
+    ) -> Dict:
         """Score experience with optimized processing"""
         if not experience:
-            return {'score': 0, 'matching': [], 'missing': [], 'explanation': 'No experience provided'}
-            
+            return {
+                "score": 0,
+                "matching": [],
+                "missing": [],
+                "explanation": "No experience provided",
+            }
+
         base_score = 60
-        
-        required_keys = {'title', 'company', 'description'}
-        improvement_keywords = {'increased', 'decreased', 'improved', '%', 'reduced'}
-        
+
+        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):
+
+            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]]
-        
+            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)
-        )
+
+        response = self._parse_gemini_response(get_response(prompt, SYSTEM_INSTRUCTION))
         return {
-            'score': (base_score + (response['score'] * 10)) / 2,
-            'matching': response['matching'],
-            'missing': response['missing'],
-            'explanation': response['explanation']
+            "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'}
-            
+            return {
+                "score": 0,
+                "matching": [],
+                "missing": [],
+                "explanation": "No education provided",
+            }
+
         score = 70
         matching = []
-        
-        required_keys = {'institution', 'degree', 'start_date', 'end_date'}
-        
+
+        required_keys = {"institution", "degree", "start_date", "end_date"}
+
         for edu in education:
-            gpa = edu.get('gpa')
+            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', '')}")
-                
+                matching.append(
+                    f"{edu.get('degree', '')} from {edu.get('institution', '')}"
+                )
+
         return {
-            'score': min(100, score),
-            'matching': matching,
-            'missing': [],
-            'explanation': 'Education assessment completed'
+            "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')
-        
+
+        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]
+
+        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_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'
+            "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:
@@ -182,102 +221,125 @@ class ATSResumeParser:
             "patents": 15,
             "professional_affiliations": 10,
             "portfolio_links": 10,
-            "summary_or_objective": 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())
+                matching.append(section.replace("_", " ").title())
             else:
-                missing.append(section.replace('_', ' ').title())
-        
+                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'
+            "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:
+    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': []}
+        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)
+                "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']
-                
+
+                scores[category] = result["score"]
+
                 weight = self.score_weights[category] / 100
-                total_score += result['score'] * weight
-                
+                total_score += result["score"] * weight
+
                 detailed_feedback[category] = {
-                    'matching_elements': result['matching'],
-                    'missing_elements': result['missing'],
-                    'explanation': result['explanation']
+                    "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('_', ' ')}")
-        
+
+                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
+            "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:
+
+def generate_ats_score(
+    structured_data: Union[Dict, str], job_des_text: Optional[str] = None
+) -> Dict:
     """Generate ATS score with optimized processing"""
     try:
         logger.info("Starting ATS score generation")
         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)
-        
+
         logger.info("ATS score generation completed successfully")
         return {
-            'ats_score': result['total_score'],
-            'detailed_scores': result['detailed_scores'],
-            'feedback': result['feedback'],
-            'detailed_feedback': result['detailed_feedback']
+            "ats_score": result["total_score"],
+            "detailed_scores": result["detailed_scores"],
+            "feedback": result["feedback"],
+            "detailed_feedback": result["detailed_feedback"],
         }
-        
+
     except Exception as e:
         error_msg = f"Error generating ATS score: {e}"
         logger.error(error_msg)
         logger.debug(traceback.format_exc())
-        return {"ats_score": 50.0, "detailed_scores": {}, "feedback": {"error": error_msg}}
+        return {
+            "ats_score": 50.0,
+            "detailed_scores": {},
+            "feedback": {"error": error_msg},
+        }

Process/views.py

@@ -26,6 +26,7 @@ except Exception as e:
     logger.error(f"Failed to load model: {e}")
     logger.debug(traceback.format_exc())
 
+
 def get_embeddings(texts):
     try:
         logger.debug(f"Generating embeddings for {len(texts)} texts")
@@ -39,6 +40,7 @@ def get_embeddings(texts):
         logger.debug(traceback.format_exc())
         return None
 
+
 def calculate_similarity(job_description, resume_text):
     try:
         logger.info("Calculating similarity between job description and resume")
@@ -54,21 +56,22 @@ def calculate_similarity(job_description, resume_text):
         logger.debug(traceback.format_exc())
         return 0.0
 
+
 @csrf_exempt
 def process_resume(request):
-    if request.method == 'POST':
+    if request.method == "POST":
         try:
             logger.info("Processing resume request")
             data = json.loads(request.body)
 
-            user_id = data.get('user_id')
-            file_link = data.get('file_link')
-            job_description = data.get('job_description')
+            user_id = data.get("user_id")
+            file_link = data.get("file_link")
+            job_description = data.get("job_description")
             logger.info(f"Received data for user_id: {user_id}")
-            
+
             if not all([user_id, file_link, job_description]):
                 logger.warning("Missing required fields in request")
-                return JsonResponse({'error': 'Missing required fields'}, status=400)
+                return JsonResponse({"error": "Missing required fields"}, status=400)
 
             logger.info("Extracting Text from the pdf")
             resume = extract_text_from_pdf(file_link)
@@ -83,37 +86,39 @@ def process_resume(request):
             logger.info("ATS score generation completed")
 
             response_data = {
-                'user_id': user_id,
-                'similarity': "100.00",
-                'ats_score': ats_score,
-                'structured_data': st_data
+                "user_id": user_id,
+                "similarity": "100.00",
+                "ats_score": ats_score,
+                "structured_data": st_data,
             }
             logger.info("Sending successful response")
             return JsonResponse(response_data, status=200)
         except json.JSONDecodeError as e:
             logger.error(f"Invalid JSON received: {e}")
-            return JsonResponse({'error': 'Invalid JSON format'}, status=400)
+            return JsonResponse({"error": "Invalid JSON format"}, status=400)
         except Exception as e:
             error_msg = f"Error processing resume: {e}"
             logger.error(error_msg)
             logger.debug(traceback.format_exc())
-            return JsonResponse({'error': error_msg}, status=500)
+            return JsonResponse({"error": error_msg}, status=500)
     else:
         logger.warning(f"Unsupported method: {request.method}")
-        return JsonResponse({'message': 'Only POST requests are allowed'}, status=405)
+        return JsonResponse({"message": "Only POST requests are allowed"}, status=405)
+
 
 def verify_api(request):
     logger.info(f"API verification request received via {request.method}")
-    if request.method == 'GET':
-        return JsonResponse({'message': 'yaay working-GET '}, status=200)
+    if request.method == "GET":
+        return JsonResponse({"message": "yaay working-GET "}, status=200)
     else:
         logger.warning(f"Unsupported method for API verification: {request.method}")
-        return JsonResponse({'error': 'Only GET requests are allowed'}, status=405)
+        return JsonResponse({"error": "Only GET requests are allowed"}, status=405)
+
 
 def home(request):
     logger.info(f"Home request received via {request.method}")
-    if request.method == 'GET':
-        return JsonResponse({'message': 'Welcome To Resume-ATS'}, status=200)
+    if request.method == "GET":
+        return JsonResponse({"message": "Welcome To Resume-ATS"}, status=200)
     else:
         logger.warning(f"Unsupported method for home: {request.method}")
-        return JsonResponse({'error': 'Only GET requests are allowed'}, status=405)
+        return JsonResponse({"error": "Only GET requests are allowed"}, status=405)

ResumeATS/settings.py

@@ -13,6 +13,7 @@ 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
@@ -27,60 +28,60 @@ SECRET_KEY = os.getenv("SECRET_KEY")
 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG = False
 
-ALLOWED_HOSTS = ["127.0.0.1","harish20205-resume-ats.hf.space"]
+ALLOWED_HOSTS = ["127.0.0.1", "harish20205-resume-ats.hf.space"]
 
 
 # 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',
+    "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',
+    "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'
+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',
+        "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'
+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',
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": BASE_DIR / "db.sqlite3",
     }
 }
 
@@ -90,16 +91,16 @@ DATABASES = {
 
 AUTH_PASSWORD_VALIDATORS = [
     {
-        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
     },
     {
-        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
     },
     {
-        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
     },
     {
-        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
     },
 ]
 
@@ -107,9 +108,9 @@ AUTH_PASSWORD_VALIDATORS = [
 # Internationalization
 # https://docs.djangoproject.com/en/5.1/topics/i18n/
 
-LANGUAGE_CODE = 'en-us'
+LANGUAGE_CODE = "en-us"
 
-TIME_ZONE = 'UTC'
+TIME_ZONE = "UTC"
 
 USE_I18N = True
 
@@ -119,9 +120,9 @@ USE_TZ = True
 # Static files (CSS, JavaScript, Images)
 # https://docs.djangoproject.com/en/5.1/howto/static-files/
 
-STATIC_URL = 'static/'
+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'
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"