created app.py

app.py

@@ -0,0 +1,732 @@
+import json
+import logging
+import os
+import pickle
+import re
+import threading
+import time
+import warnings
+from concurrent.futures import ThreadPoolExecutor
+
+import fitz
+import joblib
+import nltk
+import numpy as np
+import pandas as pd
+import pdfplumber
+import pendulum
+import requests
+import spacy
+import tensorflow as tf
+import tensorflow_hub as hub
+import torch
+from bs4 import BeautifulSoup
+from gensim.models import Word2Vec
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_groq import ChatGroq
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.model_selection import train_test_split
+from transformers import (BertModel, BertTokenizer,
+                          TFBertForSequenceClassification)
+
+# Set the logging level to WARNING to suppress DEBUG and INFO logs
+logging.basicConfig(level=logging.WARNING)
+import os
+
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+import logging
+
+logging.getLogger('tensorflow').setLevel(logging.ERROR)
+
+# Set the logging level to WARNING to suppress DEBUG and INFO logs
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+logging.getLogger("groq._base_client").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.INFO)
+logging.getLogger("urllib3").setLevel(logging.INFO)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+logging.basicConfig(level=logging.DEBUG)
+warnings.filterwarnings("ignore")
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def pdf_to_text(pdf_path):
+    pdf_document = fitz.open(pdf_path)
+    text = ""
+    for page_num in range(pdf_document.page_count):
+        page = pdf_document.load_page(page_num)
+        text += page.get_text()
+    return text
+
+resumeLink='Datasets\Jay_Telgote_Resume (1).pdf'
+jd_path='Datasets\JD.txt'
+json_path='Datasets\country_data.json'
+resume = pdf_to_text(resumeLink)
+with open(jd_path, 'r') as f:
+    jd=f.read()
+
+path='Datasets\sent-models-transformers-default-v1'
+bert_tokenizer = BertTokenizer.from_pretrained(path +'\output_directory2')
+bert_model = TFBertForSequenceClassification.from_pretrained(path +'\Model2')
+
+country='Japan'
+class MasterOther:
+    def __init__(self):
+        self.backlink_score = 0
+        self.font_size_score = 0
+        self.font_name_score = 0
+        self.image_score = 0
+        self.table_score = 0
+        self.page_count_score = 0
+
+    def normalize_value(self, value, min_value, max_value):
+        if value < min_value:
+            return 0
+        return (value - min_value) / (max_value - min_value)
+
+    def extract_pdf_fonts_and_sizes(self, pdf_file_path):
+        doc = fitz.open(pdf_file_path)
+        font_sizes = set()
+
+        for page in doc:
+            blocks = page.get_text("dict")["blocks"]
+            for block in blocks:
+                if "lines" in block:
+                    for line in block["lines"]:
+                        for span in line["spans"]:
+                            font_sizes.add(span["size"])
+
+        doc.close()
+        return font_sizes
+
+    def extract_pdf_fonts_and_sizes_score(self, path):
+        font_sizes = self.extract_pdf_fonts_and_sizes(path)
+        score = 20
+        max_score = 20
+        min_score = 0
+
+        for size in font_sizes:
+            if size > 20.0 or size < 5.0:
+                score = 0
+                print('Tailor the font size accordingly')
+                break
+        self.font_size_score = self.normalize_value(score, min_score, max_score)
+
+    def check_backlinks(self, path):
+        score = 10
+        max_score = 10
+        min_score = 0
+        doc = fitz.open(path)
+        page = doc.load_page(0)
+        links = page.get_links()
+        if links:
+            score = 0
+            print('Resume contain backlinks')
+        doc.close()
+        self.backlink_score = self.normalize_value(score, min_score, max_score)
+
+    def contains_table(self, path):
+        score = 10
+        max_score = 10
+        min_score = 0
+        with pdfplumber.open(path) as pdf:
+            for page in pdf.pages:
+                tables = page.extract_tables()
+                if tables:
+                    score -= 5
+                    if score==0:
+                        break
+        if score<max_score:
+            print('Resume contain tables')
+        self.table_score = self.normalize_value(score, min_score, max_score)
+
+    def contains_images(self, pdf_file_path):
+        score = 10
+        max_score = 10
+        min_score = 0
+        doc = fitz.open(pdf_file_path)
+        for page_num in range(len(doc)):
+            page = doc.load_page(page_num)
+            image_list = page.get_images(full=True)
+            if image_list:
+                score = 0
+                print('Resume contain images')
+                break
+        doc.close()
+        self.image_score = self.normalize_value(score, min_score, max_score)
+
+    def detect_fonts(self, pdf_path):
+        doc = fitz.open(pdf_path)
+        font_counts = {}
+
+        for page_num in range(len(doc)):
+            page = doc.load_page(page_num)
+            blocks = page.get_text("dict")["blocks"]
+
+            for block in blocks:
+                if "lines" in block:
+                    for line in block["lines"]:
+                        for span in line["spans"]:
+                            font_name = span["font"]
+                            if font_name in font_counts:
+                                font_counts[font_name] += 1
+                            else:
+                                font_counts[font_name] = 1
+
+        doc.close()
+        return font_counts
+
+    def tune_font(self, path):
+        score = 100
+        max_score = 100
+        min_score = 18
+        font_counts = self.detect_fonts(path)
+        never_use_fonts = ['Comic Sans', 'Futura', 'Lucida Console', 'Bradley Hand ITC', 'Brush Script']
+        for font, count in font_counts.items():
+            if font in never_use_fonts:
+                score -=count*18
+                print(f"{font} is not recommended for resume")
+                break
+        self.font_name_score = self.normalize_value(score, min_score, max_score)
+
+    def count_pdf_pages_score(self, pdf_path):
+        doc = fitz.open(pdf_path)
+        num_pages = doc.page_count
+        doc.close()
+        score = 30
+        max_value = 30
+        min_value = 7
+        if num_pages == 2:
+            score -= 13
+        elif num_pages > 2:
+            print('Resume should not be more than 2 pages')
+            score -= 23
+        if score < min_value:
+            score = 0
+        self.page_count_score = self.normalize_value(score, min_value, max_value)
+def all_other(master_score,path):
+    master = MasterOther()
+    master.extract_pdf_fonts_and_sizes_score(path)
+    master.check_backlinks(path)
+    master.contains_table(path)
+    master.contains_images(path)
+    master.tune_font(path)
+    master.count_pdf_pages_score(path)
+    mean=((master.font_size_score)+(master.table_score)+(master.font_name_score)+(master.backlink_score)+(master.page_count_score)+(master.image_score))/6      # Normalized image score
+    master_score['score_other']=mean*100
+    
+    
+   ############################################################## 
+    
+
+def calculate_similarity_use(text1, text2):
+
+    model = hub.load("https://tfhub.dev/google/universal-sentence-encoder/4")
+
+    embeddings = model([text1, text2])
+
+    similarity_score = cosine_similarity(embeddings)[0, 1]
+
+    return similarity_score
+
+def containment_similarity(text1, text2):
+    # Tokenize the texts
+    set1 = set(text1.split())
+    set2 = set(text2.split())
+
+    # Calculate intersection
+    intersection = set1.intersection(set2)
+
+    containment_score = len(intersection) / min(len(set1), len(set2))
+
+    return containment_score
+
+
+def remove_special_characters(text):
+    pattern = r"[.,!()*&⋄:|/^]"
+    cleaned_text = re.sub(pattern, "", text)
+    tex=cleaned_text.replace('\n','')
+    return tex.lower()
+def logic_similarity_matching(text1,text2):
+
+  score_encoder=0
+  score_containment=0
+  text1=remove_special_characters(text1)
+  text2=remove_special_characters(text2)
+  similarity_score_use = calculate_similarity_use(text1, text2)
+
+  similarity_score = containment_similarity(text1, text2)
+  if similarity_score>0.8:
+    score_containment+=1
+
+  if similarity_score_use>=0.75:
+    score_encoder=1
+  return score_encoder == 1 and score_containment == 0
+
+def normalize_value(value, min_value, max_value):
+    return (value - min_value) / (max_value - min_value)
+
+
+def logic_similarity_matching2(text1,text2,master_score):
+    score=10
+    max_score=10
+    min_score=0
+    if logic_similarity_matching(text1,text2)==False:
+        score-=10
+        print('Resume not tailored according to JD')
+        
+    master_score['similarity_matching_score']= normalize_value(score, min_score, max_score)
+    
+#################################################
+
+master_score={}
+def get_bert_embeddings(texts):
+    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+    model = BertModel.from_pretrained('bert-base-uncased')
+
+    inputs = tokenizer(texts, return_tensors='pt', padding=True, truncation=True, max_length=512)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    return outputs.last_hidden_state.mean(dim=1).numpy()
+
+# Function to predict resume scores
+def predict_resume_score(new_resumes):
+    # Generate BERT embeddings for the new resumes
+    regressor = joblib.load('Datasets\jghfgdf-keras-default-v1\model_filename2.pkl')
+
+    embeddings = get_bert_embeddings(new_resumes)
+    X_new = torch.tensor(embeddings, dtype=torch.float32)
+    
+    # Predict using the trained Random Forest Regressor
+    predictions = regressor.predict(X_new)
+    
+    return predictions
+def normalize_value(value, min_value, max_value):
+    return (value - min_value) / (max_value - min_value)
+
+
+
+def logic_actionable_words(text,master_score):
+    score=0
+    max_score=100
+    min_score=0
+    pred_score=predict_resume_score(text)[0]*100
+    if int(pred_score)>50:
+        score=100
+    elif int(pred_score)>=40 and int(pred_score)<=49:
+        score=80
+    elif int(pred_score)>=30 and int(pred_score)<=39:
+        score=60
+    elif int(pred_score)>=20 and int(pred_score)<=29:
+        print('Resume contain some Non Action Keywords or Resume dont has Actionable Keywords ')
+        score=40
+    else:
+        score=10
+        print('Resume contain some Non Action Keywords or Resume dont has Actionable Keywords ')
+    master_score['Action_score']= normalize_value(score, min_score,max_score)
+    
+    
+    
+   ############################################################## 
+groq_api_key = os.getenv('API_KEY')
+
+
+llm = ChatGroq(
+    groq_api_key=groq_api_key,
+    model_name='llama3-70b-8192'
+)
+
+
+
+def keep_only_alphanumeric(text):
+    pattern = r'[^a-zA-Z0-9]'
+
+    cleaned_text = re.sub(pattern, ' ', text.lower())
+    return ' '.join(cleaned_text.split())
+
+def groq(jd):
+
+
+    system = '''
+    1. Act as a Minium No of Experience required telling person.
+    2. The user will provide input as Job description, you have to give him minimun no of experience required to apply for the job
+    3. If you will not able to find any kind of expereince or find that Freshers can apply then just respond with "0.0".
+    4. Do not give any introduction about who you are and what you are going to be doing.
+    5. you will give the no of experience in number like 8 years, not in like eight years or someting.
+    6. remember this formula Years= Month no/12 so for 2 months it is 0.17 in round figure
+    7. Always give no of experience in decimal, for 4 years it you should give me 4.0 similarly for 6 months you  should give me 0.5 dont add any alphabetic words there.
+    '''
+    
+    human = "{text}"
+    prompt = ChatPromptTemplate.from_messages([("system", system), ("human", human)])
+
+    chain = prompt | llm
+    jd2=keep_only_alphanumeric(jd)
+    res = chain.invoke({"text": jd2})
+    p = dict(res)
+    final_text = ' '.join(p['content'].split())
+    return final_text
+
+
+def parse_date(date_str):
+    try:
+        parsed_date = pendulum.parse(date_str, strict=False)
+        return parsed_date
+    except ValueError:
+        raise ValueError(f"No valid date format found for '{date_str}'")
+
+def calculate_experience(start_date, end_date):
+    duration = end_date.diff(start_date)
+    years = duration.years
+    months = duration.months
+    return years + months / 12
+
+def calculate_total_experience(resume_text):
+    # Regular expression to match date ranges with various formats including year-only ranges
+    date_range_pattern = re.compile(
+        r'((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)[\s\'\"`*+,\-–.:/;!@#$%^&(){}\[\]<>_=~`]*\d{2,4}|\d{1,2}/\d{1,2}/\d{4}|\d{1,2}/\d{4}|\d{4})\s*(?:[-–to ]+)\s*((?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)[\s\'\"`*+,\-–.:/;!@#$%^&(){}\[\]<>_=~`]*\d{2,4}|\d{1,2}/\d{1,2}/\d{4}|\d{1,2}/\d{4}|\d{4}|\b[Tt]ill\b|\b[Nn]ow\b|\b[Pp]resent\b|\b[Oo]ngoing\b|\b[Cc]ontinue\b|\b[Cc]urrent\b)?'
+    )
+
+    date_matches = date_range_pattern.findall(resume_text)
+        
+    total_experience = 0
+    
+    for start_date_str, end_date_str in date_matches:
+        try:
+            start_date = parse_date(start_date_str.strip())
+            end_date = pendulum.now() if not end_date_str or end_date_str.strip().lower() in ['till', 'now', 'present', 'ongoing', 'continue', 'current'] else parse_date(end_date_str.strip())
+                        
+            experience = calculate_experience(start_date, end_date)
+            
+            total_experience += experience
+        except ValueError as e:
+            print(e)
+    
+    return round(total_experience, 2)
+calculate_total_experience(resume)
+
+
+def extract_experience(text):
+    experience_pattern = (
+        r"\b(?:Experience|Experiences|Employments?|Work History|Professional Background|"
+        r"Career History|Professional Experience|Job History|Work Experience|"
+        r"Job Experiences?|Employment History|Work Experiences?|Professional Experiences?|"
+        r"WORK EXPERIENCE)\b"
+        r"[\s:\-\n]*"
+        r"(.+?)(?=\b(?:Skills?|Abilities?|Competenc(?:ies|y)|Expertise|Skillset|"
+        r"Technical Skills?|Technical Abilities?|Projects?|Project Work|Case Studies|"
+        r"Education|Educations|Academic Background|Qualifications|Studies|its last|"
+        r"Soft Skills|Achievements|$))"
+    )
+    experience_match = re.search(experience_pattern, text, re.DOTALL | re.IGNORECASE)
+    if experience_match:
+        return experience_match.group(1).strip()
+    return None
+
+main_score={}
+def to_check_exp(resume, jd,main_score):
+    required_experience = float(groq(jd))
+    tt=extract_experience(resume)
+    candidate_experience = float(calculate_total_experience(tt))
+    if candidate_experience < required_experience:
+        print('User experience does not matches with the Job Description')
+    main_score['exp_match']=int(candidate_experience >= required_experience)
+    
+
+    
+    
+####################################################
+def extract_skills(text):
+    skills_pattern = (
+        r"\b(Skill(?:s|z)?|Abilit(?:ies|y|tys)?|Competenc(?:ies|y)|Expertise|Skillset|Technical Skills?|Technical Abilities?|Technological Skills?|TECHNICAL SKILLS?|Technical Expertise)\b"
+        r"[\s:\-\n]*"
+        r"(.+?)(?=\b(Experience|Experiences|Employment|Work History|Professional Background|Projects|its last|Project Work|Case Studies|Education|Educations|Academic Background|Qualifications|Studies|Soft Skills|Achievements|$))"
+    )
+    skills_match = re.search(skills_pattern, text, re.DOTALL | re.IGNORECASE)
+    if skills_match:
+        return skills_match.group(2).strip()
+    return None
+
+def extract_experience(text):
+    experience_pattern = (
+        r"\b(Experience|Experiences|Employments?|Work History|Professional Background|Career History|Professional Experience|Job History|Work Experience|Job Experiences?|Employment History|Work Experiences?|Professional Experiences?|WORK EXPERIENCE)\b"
+        r"[\s:\-\n]*"
+        r"(.+?)(?=\b(Skills?|Abilities?|Competenc(?:ies|y)|Expertise|Skillset|Technical Skills?|Technical Abilities?|Projects?|Project Work|Case Studies|Education|Educations|Academic Background|Qualifications|Studies|its last|Soft Skills|Achievements|$))"
+    )
+    experience_match = re.search(experience_pattern, text, re.DOTALL | re.IGNORECASE)
+    if experience_match:
+        return experience_match.group(2).strip()
+    return None
+
+def extract_education(text):
+    education_pattern = (
+        r"\b(Education|Educations|Academic Background|Qualifications|Studies|Academic Qualifications|Educational Background|Academic History|Educational History|Education and Training|Educational Qualifications|EDUCATION)\b"
+        r"[\s:\-\n]*"
+        r"(.+?)(?=\b(Skills?|Abilities?|Competenc(?:ies|y)|Expertise|Skillset|Technical Skills?|Technical Abilities?|Experience|Experiences|Employment|Work History|Professional Background|Projects?|Project Work|Case Studies|its last|Soft Skills|Achievements|$))"
+    )
+    education_match = re.search(education_pattern, text, re.DOTALL | re.IGNORECASE)
+    if education_match:
+        return education_match.group(2).strip()
+    return None
+
+
+
+
+def parsed(resume1):
+    resume1=resume1+'    its last'
+    resume1=resume1.replace('\n',' ')
+
+    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+    phone_pattern = r'(\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}|\+\d{2,4}[-.\s]?\d{10}|\d{10}|\d{11})'
+
+    email_match = re.search(email_pattern, resume1)
+    phone_match = re.search(phone_pattern, resume1)
+
+    email = email_match.group() if email_match else None
+    phone = phone_match.group() if phone_match else None
+
+
+    skills = extract_skills(resume1)
+
+    experience = extract_experience(resume1)
+
+    education = extract_education(resume1)
+
+
+
+    return {
+        'Email': email,
+        'Phone': phone,
+        'Skills': skills.replace('\n','') if skills else None,
+        'Experience': experience.replace('\n','') if experience else None,
+        'Education': education.replace('\n','') if education else None,
+    }
+def resume_parsing_2(resume,master_score):
+    parsed_resume = parsed(resume)
+    if any(value is None for value in parsed_resume.values()):
+        print('Resume template is not ATS friendly.')
+        master_score['Parsing_score']= 0
+    else:
+        master_score['Parsing_score']= 1
+
+
+###################################
+
+
+
+import os
+import sys
+
+
+def Get_sentiment(Review, Tokenizer=bert_tokenizer, Model=bert_model, threshold=0.5):
+    if not isinstance(Review, list):
+        Review = [Review]
+    Input_ids, Token_type_ids, Attention_mask = Tokenizer.batch_encode_plus(Review,
+                                                                            padding=True,
+                                                                            truncation=True,
+                                                                            max_length=128,
+                                                                            return_tensors='tf').values()
+    
+    # Redirect stdout to suppress progress messages
+    original_stdout = sys.stdout
+    sys.stdout = open(os.devnull, 'w')  # Suppress output
+
+    prediction = Model.predict([Input_ids, Token_type_ids, Attention_mask])
+    
+    # Restore stdout
+    sys.stdout.close()
+    sys.stdout = original_stdout
+
+    probs = tf.nn.softmax(prediction.logits, axis=1)
+    pred_labels = tf.argmax(probs, axis=1)
+    pred_probs = probs.numpy().tolist()
+    return pred_probs[0][1]
+
+
+
+word2vec_model=joblib.load(r'Datasets\4-tensorflow2-default-v1\word2vec_res_model.pkl')
+model=joblib.load(r'Datasets\4-tensorflow2-default-v1\word_matrix_ml_model.pkl')
+def get_average_word2vec(words, word2vec_model):
+    word_vectors = [word2vec_model.wv[word] for word in words if word in word2vec_model.wv]
+    if not word_vectors:
+        return np.zeros(word2vec_model.vector_size)
+    return np.mean(word_vectors, axis=0)
+
+def another_word2vec(texts):
+  X_new = np.array([get_average_word2vec(texts, word2vec_model)])
+
+  new_predictions = model.predict(X_new)
+  return  new_predictions
+
+def semi_final(texts):
+    min_score = 0
+    max_score = 10
+    sentiment_score = np.mean([Get_sentiment(text) for text in texts])
+    
+    if sentiment_score > 0.8:
+        word2vec_score = np.mean([another_word2vec(text) for text in texts]) * 100
+        
+        if 70 <= word2vec_score < 85:
+            score = 8
+        elif word2vec_score >= 86:
+            score = 10
+        elif 50 <= word2vec_score < 69:
+            score = 6
+        elif 30 <= word2vec_score < 49:
+            score = 4
+        else:
+            score = 2
+    else:
+        print('Resume is not Customized')
+        return None
+
+    return normalize_value(score, min_score, max_score)
+
+def normalize_value(value, min_value, max_value):
+    return (value - min_value) / (max_value - min_value)
+
+def process(texts):
+    textt=(texts.lower()).replace('\n','').replace('\t','').replace('"','')
+    texts2=textt.split('.')
+    return [i for  i in texts2 if i!='']
+
+def finale(resume, master_score):
+    texts=process(resume)
+    score = semi_final(texts)
+    if score is not None:
+        master_score['matrix_score'] = score
+    else:
+        master_score['matrix_score'] = 0
+        
+        
+        
+#################################################################
+
+
+
+def fetch_page(country, page_number):
+    path_country=json_path
+    with open(path_country, 'r') as file:
+        countries_dict = json.load(file)
+    
+    try:
+        url = f'http://161.111.47.11:80/en/{countries_dict[country]}?page={page_number}'
+        response = requests.get(url)
+        response.raise_for_status()
+        return response.content
+    except requests.RequestException as e:
+        print(f"Error fetching page {page_number} for {country}: {e}")
+        return None
+
+def fetch_all_pages(country, num_pages=2):
+    with ThreadPoolExecutor() as executor:
+        pages_content = list(executor.map(lambda p: fetch_page(country, p), range(num_pages)))
+    return [content for content in pages_content if content]
+
+def parse_pages(pages_content):
+    institutions = set()
+    for content in pages_content:
+        soup = BeautifulSoup(content, 'html.parser')
+        rows = soup.select('tbody tr')
+        for row in rows:
+            name_element = row.select_one('td:nth-of-type(3) a')
+            if name_element:
+                institution_name = name_element.text.strip().lower()
+                institutions.add(institution_name)
+    return institutions
+
+def extract_education(text):
+    education_pattern = (
+        r"\b(Education|Educations|Academic Background|Qualifications|Studies|Academic Qualifications|Educational Background|Academic History|Educational History|Education and Training|Educational Qualifications|EDUCATION)\b"
+        r"[\s:\-\n]*"
+        r"(.+?)(?=\b(Skills?|Abilities?|Competenc(?:ies|y)|Expertise|Skillset|Technical Skills?|Technical Abilities?|Experience|Experiences|Employment|Work History|Professional Background|Projects?|Project Work|Case Studies|its last|Soft Skills|Achievements|$))"
+    )
+    education_match = re.search(education_pattern, text, re.DOTALL | re.IGNORECASE)
+    return education_match.group(2).strip() if education_match else None
+
+def extract_institutions_from_resume(resume_text):
+    pattern = r'[>(><&#%")-:\'\d]'
+    res = resume_text.replace('|', '\n')
+    cleaned_text = re.sub(pattern, '', res)
+    return [re.sub(r'\s+', ' ', inst).strip().lower() for inst in cleaned_text.splitlines() if len(inst.split()) >= 3]
+
+def main(resume_text, country='India'):
+    pages_content = fetch_all_pages(country)
+    institutions = parse_pages(pages_content)
+    
+    education_text = extract_education(resume_text)
+    if education_text:
+        resume_institutions = extract_institutions_from_resume(education_text)
+        found_institutions = [name for name in resume_institutions if name in institutions]
+        return found_institutions
+    return []
+
+
+def education_master(resume_text, master_score, country):
+    score = 0.0
+    educ_institutions = main(resume_text, country)
+    if educ_institutions:
+        if len(educ_institutions) == 1:
+            score = 0.5
+        elif len(educ_institutions) > 1:
+            score = 1.0
+    master_score['score_education_detection_'] = score
+
+
+edu_thread = threading.Thread(target=education_master, args=(resume, master_score,country))
+
+
+matrix_thread = threading.Thread(target=finale, args=(resume, master_score)) 
+
+parse_thread = threading.Thread(target=resume_parsing_2,  args=(resume,master_score))
+
+exp_thread = threading.Thread(target=to_check_exp,  args=(resume,jd,main_score))
+
+action_word_thread = threading.Thread(target=logic_actionable_words, args=(resume,master_score))
+
+simi_matching_thread = threading.Thread(target=logic_similarity_matching2, args=(resume,jd, master_score))
+
+other_thread=threading.Thread(target=all_other, args=(master_score, resumeLink))
+
+
+
+
+def normalize_scores(scores):
+    # Define the ranges for each score type
+    ranges = [
+        (0.0, 1.0),   # First score: 0 to 1
+        (0.0, 100.0), # Second score: 0 to 100
+        (0.0, 1.0),   # Third score: 0 to 1
+        (0.0, 1.0),   # Fourth score: 0 to 1
+        (0.0, 1.0),   # Fifth score: 0 to 1
+        (0.0, 1.0)    # Sixth score: 0 to 1
+    ]
+    
+    # Normalize each score
+    normalized_scores = []
+    for score, (min_val, max_val) in zip(scores, ranges):
+        normalized_score = (score - min_val) / (max_val - min_val) * 100
+        normalized_scores.append(normalized_score)
+    
+    return normalized_scores
+
+
+print('Possible Suggestions: \n')
+edu_thread.start()
+edu_thread.join()
+matrix_thread.start()
+matrix_thread.join()
+parse_thread.start()
+parse_thread.join()
+exp_thread.start()
+exp_thread.join()
+action_word_thread.start()
+action_word_thread.join()
+simi_matching_thread.start()
+simi_matching_thread.join()
+other_thread.start()
+other_thread.join()
+