Upload 6 files

src/config.py

@@ -0,0 +1,223 @@
+import os
+
+BASE_DIR = os.getcwd()
+UPLOAD_FOLDER = os.path.join(BASE_DIR, '..', 'data', 'uploads')
+ALLOWED_EXTENSIONS = {'pdf'}
+linkedin_domain = (r'https?://(www\.)?linkedin\.com/[^\s<>"]')
+github_domain = (r'https?://(www\.)?github\.com/[^\s<>"]')
+kaggle_domain = (r'https?://(www\.)?kaggle\.com/[^\s<>"]')
+medium_domain = (r'https?://(www\.)?medium\.com/[^\s<>"]')
+hackerrank_domain = (r'https?://(www\.)?hackerrank\.com/[^\s<>"]')
+leetcode_domain = (r'https?://(www\.)?leetcode\.com/[^\s<>"]')
+
+
+
+required_sections = ['PROFILE SUMMARY','ACADEMIC PROFILE','TECHNICAL SKILLS','CERTIFICATIONS','PROJECTS','CAREER OBJECTIVE']
+
+basic_informations = ["name", "contact_number", "email", "linkedin_urls", "github_urls"]
+
+data_science_skills = ['queries', 'beautifulsoup', 'ms excel', 'mathematics', 'selenium', 
+                       'html', 'analytical skills', 'statsmodels','ai', 'improvement', 
+                       'analyze', 'metrics', 'forecasting', 'analytics', 'analytical', 
+                       'mysql', 'postgresql', 'database', 'writing', 'excel','regulations', 
+                       'algorithms', 'scipy', 'opencv', 'reports',  'eda', 'jupyter', 
+                       'presentations', 'modeling', 'audit', 'technical skills', 
+                       'schedule', 'nltk', 'iso', 'xgboost', 'segmentation', 'github', 
+                       'seaborn', 'keras', 'distribution', 'investigation', 'tableau',
+                       'probability', 'analysis', 'r', 'technical', 'programming', 
+                       'web scraping', 'research', 'pandas', 'statistical analysis', 
+                       'numpy', 'predictive analysis', 'tensorflow', 'hypothesis', 
+                       'matplotlib', 'scikit-learn', 'information technology', 
+                       'machine learning', 'cloud', 'streamlit', 'mining', 'python', 
+                       'data analytics', 'deep learning', 'testing', 'training', 
+                       'clustering & classification', 'data analysis', 'engineering', 
+                       'data visualization', 'quantitative analysis', 'statistics', 
+                       'flask', 'statistical modeling', 'pytorch', 'data mining', 
+                       'aws', 'sql']
+
+essential_skills = ["Python", "SQL", "MySQL", "Tableau", "NumPy", 
+                    "Statsmodels", "CNN", "ANN",
+                    "RNN", "Machine Learning", "Deep Learning", "SciKit Learn", "MS Excel",
+                    "Data Visualization", "Power BI", "Data Analysis"]
+
+quality_mapping = {
+            'Resume needs significant improvement': 0.15,
+            'Resume needs improvement': 0.35,
+            'Resume is average': 0.55,
+            'Resume is good': 0.75,
+            'Resume is very good': 0.90,
+            'Resume is excellent': 1,
+            'The resume is bad': 1.1
+        }
+
+keyword_variations = {
+        "Python": ["Python", "Python_Language", "Python Programming"],
+        "SQL": ["SQL", "SQL_Language", "Structured Query Language", "Structured_Query_Language"],
+        "MySQL": ["MySQL", "MySQL_Database", "My_SQL", "My SQL"],
+        "Pandas": ["Pandas", "Pandas_Library", "Pandas Data Analysis Library","Pandas_Data Analysis_Library"],
+        "R": [" R ", "R_Programming", "R Language",",R "," R,", ",R,"],
+        "Matplotlib": ["Matplotlib", "Matplotlib_Library", "Matplotlib Plotting Library","Matplotlib_Plotting_Library"],
+        "Seaborn": ["Seaborn", "Seaborn_Library", "Seaborn Data Visualization Library"],
+        "StatsModel": ["StatsModel", "StatsModel_Library", "StatsModel Statistical Library", "Statistical Modeling Library", "Statistics Modeling", "StatModelLib", "StatsMod", "SM Library", "SM"],
+        "Tableau": ["Tableau", "Tableau_Software", "Tableau Data Visualization", "Tableau Analytics", "Tableau BI Tool", "Tableau Visualization Software", "Tableau Data Analysis", "Tableau BI","TableauBI"],
+        "TensorFlow": ["TensorFlow", "TensorFlow_Library"],
+        "NumPy": ["NumPy", "NumPy_Library", "Numerical Computing Library"],
+        "PyTorch": ["PyTorch", "PyTorch_Library"],
+        "Keras": ["Keras", "Keras_Library"],
+        "Plotly": ["Plotly", "Plotly_Library",],
+        "RFM": ["RFM", "RFM_Analysis", "Recency Frequency Monetary Analysis"],
+        "ANOVA": ["ANOVA", "ANOVA_Test", "Analysis of Variance","Analysis_of_Variance"],
+        "BeautifulSoup": ["BeautifulSoup", "BeautifulSoup_Library"],
+        "Imputation": ["Imputation", "Data_Imputation","Data Imputation", "Missing Data Imputation"],
+        "Scrappy": ["Scrappy", "Scrappy_Library"],
+        "Selenium": ["Selenium", "Selenium_Library", "Selenium WebDriver", "Selenium Automation"],
+        "TensorBoard": ["TensorBoard", "TensorBoard_Library", "TensorBoard Visualization Tool"],
+        "SciPy": ["SciPy", "SciPy_Library", "Scientific Computing Library"],
+        "OpenCV": ["OpenCV", "OpenCV_Library", "Computer Vision Library"],
+        "NLTK": ["NLTK", "NLTK_Library", "Natural Language Toolkit"],
+        "Hadoop": ["Hadoop", "Hadoop_Framework"],
+        "Spark": ["Spark", "Spark_Framework", "Apache_Spark"],
+        "spacy": ["spacy","Spacy_Library"],
+        "AdaBoost": ["AdaBoost","Ada_Boost","Ada Boost", "AdaBoost_Algorithm", "Adaptive Boosting","Adaptive_Boosting"],
+        "XGBoost": ["XGBoost","XG_Boost","XG Boost", "XGBoost_Algorithm", "Extreme Gradient Boosting"],
+        "CNN": [" CNN ", "CNN,", ",CNN", "Convolutional Neural Network", "ConvNet", "CNN Algorithm","CNN"],
+        "ANN": [" ANN ", "ANN,", ",ANN", "Artificial Neural Network", "ANN Algorithm","ANN"],
+        "RNN": [" RNN ", "RNN,", ",RNN", "Recurrent Neural Network", "RNN Algorithm","RNN"],
+        "KNN": [" kNN ", "kNN,", ",kNN","K-Nearest Neighbours", "K_Nearest_Neighbours", "K-Nearest-Neighbours", "K Nearest Neighbours", "KNN"],
+        "LSTM": ["LSTM", "Long Short-Term Memory", "LSTM Network", "LSTM Algorithm"],
+        "GAN": [" GAN ", "GAN,", ",GAN", "Generative Adversarial Network", "GAN Algorithm"," GAN "],
+        "YOLO": ["YOLO", "You Only Look Once", "YOLO_Algorithm"],
+        "Clustering": ["Clustering", "Clustering_Algorithms", "Data_Clustering"],
+        "Classification": ["Classification", "Classification_Algorithms", "Data_Classification"],
+        "Word2Vec": ["Word2Vec", "Word2Vec_Algorithm", "Word2Vec Word Embeddings","word2vector"],
+        "Tf-idf": ["Tf-idf","Tf_idf","Tf idf", "Term Frequency-Inverse Document Frequency", "Tf_idf_Algorithm","Tf-idf_Algorithm"],
+        "Tokenization": ["Tokenization", "Text_Tokenization", "Word_Tokenization"],
+        "Machine Learning": ["Machine Learning", "Machine_Learning", "Machine Learning Algorithms", "Machine_Learning_Algorithms", "ML"],
+        "Deep Learning": ["Deep Learning", "Deep_Learning", "Deep Learning Algorithms", "Deep_Learning_Algorithms", "DL"],
+        "SciKit Learn": ["SciKit Learn", "SciKit_Learn", "Sci Kit Learn", "SciKit-Learn","Sci_Kit_Learn", "sklearn","sk_learn"],
+        "Hugging Face": ["Hugging Face", "Hugging_Face", "HuggingFace"],
+        "MS Excel": ["Excel", "MS Excel","MSExcel", "MS_Excel", "Microsoft_Excel", "Microsoft Excel", "advance_excel","advance_MS_excel","advance_MSexcel", "advance excel", "Advance_Microsoft_excel", "Advance Microsoft excel"],
+        "Data Visualization": ["Data Visualization", "Data_Visualization", "Data_Viz", "Visualization"],
+        "Power BI": ["Power BI", "Power_BI", "Microsoft_Power_BI", "Microsoft Power BI","PowerBI"],
+        "Transfer Learning": ["Transfer Learning", "Transfer_Learning"],
+        "Linear Regression": ["Linear Regression", "Linear_Regression"],
+        "Logistic Regression": ["Logistic Regression", "Logistic_Regression"],
+        "Decision Tree": ["Decision Tree", "Decision_Tree"],
+        "Random Forest": ["Random Forest", "Random_Forest"],
+        "K-Means Clustering": ["K-Means Clustering", "K_Means_Clustering", "K-Means-Clustering", "K Means Clustering", "K-means", "k_means","K-mean", "k_mean"],
+        "T-test": ["T-test", "T_Test", "T Test"],
+        "Z-test": ["Z-test", "Z_Test", "Z Test"],
+        "Hypothesis Testing": ["Hypothesis Testing", "Hypothesis_Testing"],
+        "Chi-square": ["Chi-square", "Chi_Square", "Chi2"],
+        "Normal Distribution": ["Normal Distribution", "Normal_Distribution"],
+        "Correlation Analysis": ["Correlation Analysis", "Correlation_Analysis"],
+        "Feature Scaling": ["Feature Scaling", "Feature_Scaling"],
+        "Dimensionality Reduction": ["Dimensionality Reduction", "Dimensionality_Reduction"],
+        "Jupyter Notebook": ["Jupyter Notebook", "Jupyter_Notebook"],
+        "Google Colab": ["Google Colab", "Google_Colab"],
+        "Data Analysis": ["Data Analysis", "Data_Analysis"],
+        "Big Data": ["Big Data", "Big_Data"],
+        "Support Vector Machines (SVM)": ["Support Vector Machines (SVM)", "Support_Vector_Machines", "SVM", "Support Vector Machines", "Support_Vector_Machines_SVM"],
+        "Natural Language Processing": ["Natural Language Processing", "Natural_Language_Processing", "NLP"],
+        "Artificial Intelligence": ["Artificial Intelligence", "Artificial_Intelligence"," AI ",",AI "," AI,","AI"],
+        "Naive Bayes": ["Naive Bayes", "Naive_Bayes"],
+        "Principal Component Analysis (PCA)": ["Principal Component Analysis (PCA)", "Principal_Component_Analysis", "Principal Component Analysis", "PCA"],
+        "Descriptive Statistics": ["Descriptive Statistics", "Descriptive_Statistics"],
+        "Inferential Statistics": ["Inferential Statistics", "Inferential_Statistics"],
+        "Gradient Boosting Machines (GBM)": ["Gradient Boosting Machines (GBM)", "Gradient_Boosting_Machines", "Gradient Boosting Machines", "GBM","Gradient Boosting","Gradient_Boosting"],
+        "Association Rule Learning (Apriori)": ["Association Rule Learning (Apriori)", "Association_Rule_Learning", "Association Rule Learning", "Apriori"],
+        "Hierarchical Clustering": ["Hierarchical Clustering", "Hierarchical_Clustering"],
+        "Image Segmentation": ["Image Segmentation", "Image_Segmentation"],
+        "Object Detection": ["Object Detection", "Object_Detection"],
+        "Encoder Decoder": ["Encoder - Decoder", "Encoder_Decoder","Encoder Decoder","Encoder Decode",
+                              "Sequence-to-Sequence Models", "Seq2Seq Models", "Language Encoding", "Language Decoding", "Text Encoding", "Text Decoding",
+                              "Image Encoding", "Image Decoding", "Audio Encoding", "Audio Decoding", "Video Encoding", "Video Decoding", "Speech Encoding", "Speech Decoding", "Data Compression",
+                              "Data Encryption", "Data Decryption","Encoder","Decoder"],
+        "Word Embedding": ["Word Embedding", "Word_Embedding"],
+        "Bag of Words": ["Bag of Words", "Bag_of_Words"],
+        "Sentiment Analysis": ["Sentiment Analysis", "Sentiment_Analysis"],
+        "Predictive Analysis": ["Predictive Analysis", "Predictive_Analysis"],
+        "Statistical Modeling": ["Statistical Modeling", "Statistical_Modeling","Statistical_Analysis","Statistical Analysis"],
+        "Data Preprocessing": ["Data Preprocessing", "Data_Preprocessing"],
+        "Model Development": ["Model Development", "Model_Development"],
+        "Time Series Analysis": ["Time Series Analysis", "Time_Series_Analysis","TimeSeries","TimeSeries_Analysis"],
+        "Statistics Fundamentals": ["Statistics Fundamentals", "Statistics_Fundamentals"],
+        "Advanced ML": ["Advanced ML", "Advanced_ML", "Advanced Machine Learning", "Advanced_Machine_Learning", "Advanced-ML"],
+        "Advanced DL": ["Advanced DL", "Advanced_DL", "Advanced Deep Learning", "Advanced_Deep_Learning", "Advanced-DL"],
+        "EDA": ["EDA","Exploratory_Data_Analysis","Exploratory Data Analysis"],
+        "Data Mining":["Data Mining","Data_Mining"],
+        "Outlier Detection": ["Outlier_Detection","Outlier Detection"],
+        "Missing Values Handling": ["Missing Values Handling","Missing_Values_Handling","Missing Values"],
+        "Scaling Techniques": ["Scaling Techniques","Feature Scaling","Feature_Scaling","Data Scaling","Data_Scaling","Data Normalization","Data_Normalization","Standardization","Min-Max Scaling","Min-Max_Scaling","Normalization"],
+        "R2 and Adjusted R2": ["R2 Score","R2_Score","Adjusted_R2_Score","Adjusted R2 Score","R Squared Score","R_Squared_Score","R2 Accuracy","R2_Accuracy","Adjusted R2 Accuracy","R2 Metric","Adjusted R2 Metric"],
+        "Accuracy, Recall, F1 Score": ["Accuracy","Classification_Accuracy","Accuracy_Metrics","Recall","Precision","Recall_Score","F1 Score","F1-Score","F1_Metric","F1_Score","Classification_F1-Score"],
+        "MS Office": ["MS_Office","MS Office","Microsoft Office","MS Word","MS_Word","Microsoft_Office","Microsoft_Word","Microsoft Word"],
+        "Subquery": ["Subquery","Sub-query","Nested Query","Inner Query"],
+        "SQL Join": ["SQL Join","Join in SQL","Join"],
+        "Stemming": ["Stemming","Stemming Algorithm","Word Stemming","Stemming Techniques","Stemming in NLP","Text_Stemming","Text Stemming"],
+        "Stopwords": ["Stopwords","Stop Words","Common Words","Text Stopwords","Stopwords Removal","Removing Stopwords","Stopwords List","Stopwords in NLP"],
+        "docker_variations" : ["Docker Integration","Docker", "Docker Automation", "Advanced Docker","Advanced_Docker", "Docker Tools"],
+        "jenkins_variations" : ["Jenkins","Jenkins CI/CD","CI/CD", "Jenkins Automation", "Jenkins Pipeline", "Jenkins Plugins"],
+        "prometheus_variations" : ["Prometheus Monitoring", "Prometheus Metrics", "PromQL", "Prometheus Alerting"],
+        "cicd_variations" : ["Continuous Integration", "Continuous Deployment", "CI/CD Automation", "CI/CD Tools"],
+        "flask_variations" : ["Flask","Flask Framework", "Flask RESTful", "Flask Deployment", "Flask Security"],
+        "fastapi_variations" : ["FastAPI","FastAPI Framework", "FastAPI RESTful","FastAPI_RESTful", "FastAPI Deployment", "FastAPI Tools","FastAPI_Tools"],
+        "django_variations" : ["Django Framework", "Django Web Development", "Django REST Framework", "Django Deployment","Django"],
+        "aws_variations" : ["Amazon Web Services", "AWS Cloud", "AWS Services", "AWS Management","AWS","AWS_Cloud"],
+        "statistics_variations" : ["Statistical Analysis", "Descriptive Statistics", "Inferential Statistics", "Probability Theory"],
+        "hypothesis_testing_variations" : ["Null Hypothesis", "Alternative Hypothesis", "Significance Level", "Type I Error"],
+        "smote_variations" : ["Synthetic Minority Over-sampling Technique", "SMOTE Algorithm", "SMOTE Python", "SMOTE Applications","SMOTE"],
+        "mlflow_variations" : ["MLflow Framework", "MLflow Tracking", "MLflow Deployment", "MLflow Integration","MLflow"],
+        "packaging_variations" : ["Software Packaging", "Package Management", "Python Packaging", "Packaging Best Practices"],
+        "version_control_variations" : ["Git Version Control", "Git Commands", "Git Workflow", "Git Collaboration","Git"],
+        "communication skills" : ["communication_skills" , "communication_skill" ,"communication skills"],
+        "problem-solving": ["problem-solving","problem_solving", "problem-solving"],
+        "decision making" : ["decision making" , "decision-making","decision_making"]
+
+    }       
+
+Extract_sections = ["CAREER OBJECTIVE", "PROFILE SUMMARY"]
+
+section_headers = [
+        "CAREER OBJECTIVE", "PROFILE SUMMARY", "WORK EXPERIENCE", "EDUCATION","ADDITIONAL INFORMATION AND HOBBIES",
+        "ACADEMIC PROFILE", "PROJECTS", "CERTIFICATIONS","SKILLS",
+        "PERSONAL SKILLS", "PERSONAL INFORMATION", "REFERENCES", 
+        "EXTRACURRICULAR ACTIVITIES", "TECHNICAL SKILLS", "KEY SKILLS", 
+        "ADDITIONAL INFORMATION", "CERTIFICATIONS & ACADEMIC ENDEAVOURS", 
+        "AWARDS & ACCOLADES", "SOFTWARE SKILLS", "AWARDS"
+    ]
+
+common_projects = ["Titanic","Iris","MNIST", "COVID-19", "Bank Churn",
+                   "Spam","Handwritten Digit","Heart Disease","House Price",
+                   "Diabetes","Twitter", "Churn",
+                   "Wine Quality", "Loan","Titanic Survival Prediction",
+        "Iris Flower Classification",
+        "House Price Prediction",
+        "MNIST Handwritten Digit Recognition",
+        "Customer Churn Prediction",
+        "Sentiment Analysis of Movie Reviews",
+        "Spam Email Detection",
+        "Fake News Detection",
+        "Image Classification with CNNs",
+        "Stock Price Prediction"]
+
+suggested_projects = ["Predicting Patient Readmissions in Hospitals",
+                      "Optimizing Ad Spend with Machine Learning Models","Developing a Fake News Detection System",
+                      "Developing an AI Chatbot for Customer Service Automation","Personalized Health Recommendations Using Wearable Data"]
+
+# Specify rule IDs and error keywords to ignore
+ignore_rule_ids = ['WHITESPACE_RULE']
+ignore_error_keywords = ['repeated a whitespace']
+
+# Blogs & Articles
+blog_articles = ["https://www.dataquest.io/blog/how-data-science-resume-cv/",
+                 "https://medium.com/data-science-at-microsoft/writing-a-resume-for-a-data-science-role-345b98bdf80b",
+                 "https://medium.com/@alicechen.ai/resume-201-how-to-write-an-effective-data-science-resume-441cbe6c0932"
+                 ]
+
+# Links
+youtube_links = ["https://youtu.be/Tt08KmFfIYQ?si=EdebdWUfbttysrfL",
+                 "https://youtu.be/R3abknwWX7k?si=m4EyviXgKDoPgIGr",
+                 "https://youtu.be/1-z9ptlBar4?si=lA7WgU4j4MFGjBZV",
+                 "https://youtu.be/pjqi_M3SPwY?si=5aRizcfpreKR9xUr",
+                 "https://youtu.be/ROfceyeD7f4?si=OTbrL7BUKSW1u2mt"]

src/logging_config.py

@@ -0,0 +1,42 @@
+# src/logging_config.py
+import logging
+from logging.handlers import TimedRotatingFileHandler
+import os
+from datetime import datetime
+
+def setup_logging():
+    # Create the logs directory if it doesn't exist
+    log_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'logs')
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+
+    # Set the logging level to DEBUG
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+
+    # Create a console handler to output logs to the console
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.DEBUG)
+
+    # Create a timed rotating file handler to output logs to a file
+    today_date = datetime.now().strftime('%Y-%m-%d')
+    log_file = os.path.join(log_dir, f'{today_date}.log')
+    file_handler = TimedRotatingFileHandler(log_file, when='midnight', interval=1)
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.suffix = '%Y-%m-%d'  # Date format for log file names
+
+    # Create a formatter and set it for both handlers
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    console_handler.setFormatter(formatter)
+    file_handler.setFormatter(formatter)
+
+    # Add both handlers to the logger
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+
+    # Avoid duplicate logs by removing the default handler if present
+    if logger.hasHandlers():
+        logger.handlers.clear()
+        logger.addHandler(console_handler)
+        logger.addHandler(file_handler)

src/main.py

@@ -0,0 +1,61 @@
+import os
+from flask import Flask, jsonify, request, flash, redirect, url_for, render_template
+from submitter import ResumeSubmitter
+from reviewer import ResumeReviewer
+from resume_parser import ResumeParser
+from logging_config import setup_logging
+import json
+
+app = Flask(__name__, template_folder=os.path.join(os.path.dirname(__file__), '..', 'templates'))
+app.secret_key = 'supersecretkey'
+setup_logging()
+
+@app.route('/v1/resumes/', methods=['POST', 'GET'])
+def submit_resume():
+    if request.method == 'POST':
+        result = ResumeSubmitter().upload_file()
+        if os.path.exists(result):
+            resume_path = result  # Get the path of the uploaded resume
+            try:
+                # Redirect to the /v1/reviews/ endpoint with the resume path as a parameter
+                return redirect(url_for('get_reviews', path=resume_path))
+            except Exception as e:
+                app.logger.error("Failed to redirect to /v1/reviews/: %s", str(e))
+                return jsonify(message="failed to redirect to reviews page"), 500
+        else:
+            return jsonify(message=f"failed to submit resume, {result}"), 400
+    else:
+        return ResumeSubmitter().upload_form()
+
+@app.route("/v1/reviews/<path:path>", methods=['POST', 'GET'])
+def get_reviews(path):
+    app.logger.debug("Inside get_reviews")
+    resume_parser = ResumeParser()
+    resume_reviewer = ResumeReviewer()
+    parsed_resume_response = resume_parser.parse_text(path)
+    
+    # Check if the response data is in JSON format
+    try:
+        # Assuming parsed_resume_response.data contains the JSON string
+        parsed_resume_dict = json.loads(parsed_resume_response.data)
+    except json.JSONDecodeError:
+        app.logger.error("Failed to decode JSON from the response")
+        return "Invalid JSON response from parser", 500
+    
+    # Save the dictionary as JSON file (optional, if you want to save it to a file)
+    with open('parsed_resume.json', 'w') as json_file:
+        json.dump(parsed_resume_dict, json_file)
+    
+    # Pass the dictionary to the template
+    return render_template("review_output.html", parsed_resume=parsed_resume_dict)
+
+@app.route("/v1/users/<int:id>", methods=['GET'])
+def get_user(id):
+    return jsonify(message="user retrieved successfully! for given id {}".format(id))
+
+@app.route('/', methods=['GET'])
+def greet():
+    return render_template('home_page.html')
+
+if __name__ == '__main__':
+    app.run()

src/resume_parser.py

@@ -0,0 +1,1208 @@
+#total score = 67
+# python file to parse different section from resume
+from pdfminer.high_level import extract_pages, extract_text
+from pdfminer.layout import LTTextContainer, LTChar, LTTextLineHorizontal
+from collections import defaultdict
+from flask import jsonify
+import re, fitz, requests, logging, datetime
+import src.config as config
+from .config import data_science_skills, keyword_variations, essential_skills, quality_mapping, Extract_sections, suggested_projects, ignore_rule_ids
+from .config import required_sections, linkedin_domain, github_domain, basic_informations, section_headers, common_projects, ignore_error_keywords,blog_articles,youtube_links
+from .config import kaggle_domain,hackerrank_domain,leetcode_domain,medium_domain
+from spacy.matcher import Matcher
+import language_tool_python
+from collections import defaultdict
+import random
+tool = language_tool_python.LanguageTool('en-US')
+
+
+
+class ResumeParser:
+    
+    def extract_contact_number_from_resume(self, text):
+        contact_number = None
+        suggestion = ""
+
+        # Use regex pattern to find a potential contact number
+        pattern = r"\b(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b"
+        match = re.search(pattern, text)
+        if match:
+            contact_number = match.group()
+            # Check if the contact number is of the correct length
+            digits_only = re.sub(r'\D', '', contact_number)
+            if len(digits_only) == 10:
+                suggestion = ""
+            elif len(digits_only) > 10 and digits_only.startswith('91') and len(digits_only[2:]) == 10:
+                suggestion = ""
+            else:
+                suggestion = "Contact number should have exactly 10 digits."
+        
+        return contact_number, suggestion
+    
+
+
+    def extract_hyperlinks(self, pdf_path):
+        doc = fitz.open(pdf_path)
+        links = []
+
+        for page_num in range(len(doc)):
+            page = doc.load_page(page_num)
+            link_list = page.get_links()
+            for link in link_list:
+                uri = link.get('uri', None)
+                if uri:
+                    links.append(uri)
+
+        return links
+
+    def extract_text_from_pdf(self, pdf_path):
+        return extract_text(pdf_path)
+    
+    def extract_email_from_text(self, text):
+        pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"
+        match = re.search(pattern, text)
+        if match:
+            return match.group()
+        return None
+
+    def extract_email_from_resume(self, pdf_path):
+        text = self.extract_text_from_pdf(pdf_path)
+        email = self.extract_email_from_text(text)
+        suggestion = ""
+
+        # If no email found in text, check hyperlinks
+        if not email:
+            links = self.extract_hyperlinks(pdf_path)
+            for link in links:
+                if link.startswith('mailto:'):
+                    email_candidate = link.split('mailto:')[1]
+                    if self.is_valid_email(email_candidate):
+                        email = email_candidate
+                        break
+
+        # Additional validation for email found in text or links
+        if email and not self.is_valid_email(email):
+            suggestion += "Your email address doesn't seem to be valid. Please check and correct."
+
+        return email, suggestion
+    
+    
+    def is_valid_email(self, email):
+        # Length check
+        if len(email) > 254:
+            return False
+        
+        # Consecutive special characters check
+        if re.search(r"[._%+-]{2,}", email):
+            return False
+        
+        # Domain part validation
+        domain_part = email.split('@')[1]
+        if not re.match(r"[A-Za-z0-9.-]+\.[A-Za-z]{2,}", domain_part):
+            return False
+        
+        # Standard email format check
+        pattern = r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$"
+        return re.match(pattern, email) is not None
+    
+    
+    def extract_sections_from_resume(self, text):
+        missing_sections = []
+        sections_not_capitalized = []
+
+        for section in required_sections:
+            pattern = r"\b{}\b".format(re.escape(section))
+
+            match_obj = re.search(pattern, text, re.IGNORECASE)
+            if not match_obj:
+                missing_sections.append(section)
+            else:
+                if match_obj.group() not in map(str.upper, required_sections):
+                    sections_not_capitalized.append(section)
+
+        return missing_sections, sections_not_capitalized
+    
+    def extract_skills_from_resume(self, text):
+        if not isinstance(text, str):
+            raise ValueError(f"Expected 'text' to be a string, but got {type(text)}")
+    
+        skills = []
+        for skill in essential_skills:
+            pattern = r"\b{}\b".format(re.escape(skill))
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                skills.append(skill) 
+        return skills
+    
+    def extract_keyword_variations_from_resume(self, text):
+        found_keywords = []
+        for keyword, variations in keyword_variations.items():
+            for variation in variations:
+                if variation.lower() in text.lower(): 
+                    found_keywords.append(variation)
+                    break  
+
+        return found_keywords
+    
+    def extract_keyword_variations_from_formatted_text(self, formatted_text):
+        found_keyword_section = []
+        for keyword, variations in keyword_variations.items():
+            for variation in variations:
+                if variation.lower() in formatted_text.lower(): 
+                    found_keyword_section.append(variation)
+                    break  
+
+        return found_keyword_section
+    
+    def extract_linkedIn_urls_from_pdf(self, pdf_path):
+        linkedin_urls = None
+        pdf_document = fitz.open(pdf_path)
+        for page_num in range(len(pdf_document)):
+            page = pdf_document.load_page(page_num)
+            links = page.get_links()
+            for link in links:
+                url = link.get('uri', '')
+                if re.search(linkedin_domain, url):
+                    linkedin_urls = url
+        pdf_document.close()
+        return linkedin_urls
+
+    def extract_github_urls_from_pdf(self, pdf_path):
+        github_urls = None
+        pdf_document = fitz.open(pdf_path)
+        for page_num in range(len(pdf_document)):
+            page = pdf_document.load_page(page_num)
+            links = page.get_links()
+            for link in links:
+                url = link.get('uri', '')
+                if re.search(github_domain, url):
+                    path = re.sub(github_domain, '', url)
+                    parts = path.split('/')
+                    if len(parts) == 1: 
+                        github_urls = url
+        pdf_document.close()
+        return github_urls 
+    
+
+    def extract_extra_urls_pdf(self,pdf_path, domains):
+        extracted_urls = defaultdict(set)
+        try:
+        # Open the PDF document
+           pdf_document = fitz.open(pdf_path)
+
+        # Iterate through all pages in the PDF
+           for page_num in range(len(pdf_document)):
+                page = pdf_document.load_page(page_num)
+                links = page.get_links()
+
+                for link in links:
+                    url = link.get('uri', '')
+                    if url:  # Ensure there's a URL
+                        for domain in domains:
+                            if re.search(domain, url, re.IGNORECASE):
+                                 extracted_urls[domain].add(url)  # Add URL to the domain's set
+        except Exception as e:
+               print(f"Error processing PDF: {e}")
+        finally:
+              pdf_document.close()
+
+        return {domain: list(urls) for domain, urls in extracted_urls.items()}
+    
+    def is_valid_url(self , github_urls ):
+        suggest = ""
+        for _ in [github_urls]:  
+            if not github_urls:
+                break
+                                    
+            try:
+                response = requests.head(github_urls)
+                if response.status_code != 200:
+                    suggest = "GitHub URL is not valid, please check and correct. "
+            except requests.RequestException:
+                    suggest = "GitHub URL is not valid, please check and correct. "
+                       
+            return suggest
+        return suggest        
+        
+
+    def is_valid_name(self, name):
+        if any(char.isdigit() for char in name):
+            return False
+        if len(name.split()) > 3: 
+            return False
+        common_non_names = {"Email", "Github", "LinkedIn", "Portfolio", "Data Analyst"}
+        if name in common_non_names:
+            return False
+        return True
+          
+    def extract_name(self, resume_text):
+        
+        lines = resume_text.split('\n')
+                
+        # Use regex to find lines that likely contain names
+        name_lines = [line for line in lines if re.match(r'^[A-Za-z]*\s[A-Za-z]*', line.strip())]
+
+        names = []
+        for i in range(len(name_lines)):
+            if self.is_valid_name(name_lines[i].strip()):
+                names.append(name_lines[i].strip())
+                
+        if len(names) >= 1:
+            name = names[0]
+            suggestion = ""
+            # Check if the name parts contain only alphabetic characters
+            name_parts = name.split()
+            if any(part[0].islower() for part in name_parts):
+                suggestion += " name should start with a capital letter. "
+            return name, suggestion
+
+        return None, "No valid name found"
+ 
+    
+    def check_missing_sections(self, resume_data):
+        missing_information = []
+        for section in basic_informations:
+            if not resume_data.get(section):
+                missing_information.append(section)
+        return missing_information
+        
+    def segregate_sections(self, text):
+        header_pattern = re.compile(rf'^\s*({"|".join(re.escape(header) for header in section_headers)}):?\s*$', re.IGNORECASE)
+        sections_text = {}
+        current_section = None
+        lines = text.splitlines()
+        for line in lines:
+            clean_line = line.strip()
+            match = header_pattern.match(clean_line)
+            if match:
+                current_section = match.group(1).upper()
+                sections_text[current_section] = []
+            elif current_section:
+                sections_text[current_section].append(line.strip())
+        
+        return sections_text
+        
+    def extract_and_format_sections(self, sections_text, Extract_sections):
+        formatted_text = ""
+        for section in Extract_sections:
+            if section in sections_text:
+                section_content = " ".join(sections_text[section]).replace('\n', ' ')
+                formatted_text += f"{section}:\n{section_content}\n\n"
+        return formatted_text
+    
+    def replace_keywords_with_placeholders(self, formatted_text, found_keyword_section):
+        placeholder_text = formatted_text
+        keyword_placeholders = {}
+        
+        # Use a set to avoid duplicates and keep track of keyword placeholders
+        used_keywords = set()
+        for i, keyword in enumerate(found_keyword_section):
+            if keyword not in used_keywords:
+                used_keywords.add(keyword)
+                placeholder = f"{{KEYWORD_{i}}}"
+                keyword_placeholders[placeholder] = keyword
+                # Using word boundary to match whole words
+                placeholder_text = re.sub(r'\b' + re.escape(keyword) + r'\b', placeholder, placeholder_text, flags=re.IGNORECASE)
+                
+        return placeholder_text, keyword_placeholders
+    
+    def replace_placeholders_with_keywords(self, grammar_issues, keyword_placeholders):
+        updated_issues = []
+        for issue in grammar_issues:
+            context = issue['context']
+            for placeholder, keyword in keyword_placeholders.items():
+                context = context.replace(placeholder, keyword)
+            # Update the context in the issue dictionary
+            issue['context'] = context
+            updated_issues.append(issue)
+        return updated_issues
+
+    def grammar_check(self, placeholder_text):
+        matches = tool.check(placeholder_text)
+        grammar_issues = []
+        for match in matches:
+            issue = {
+                "context": match.context, 
+                "error": match.message,
+                "rule_id": match.ruleId,
+                "suggested_correction": match.replacements
+            }
+            grammar_issues.append(issue)
+        return grammar_issues
+    
+    def filter_grammar_issues(self, grammar_issues, ignore_rule_ids=None, ignore_error_keywords=None):
+        if ignore_rule_ids is None:
+            ignore_rule_ids = []
+        if ignore_error_keywords is None:
+            ignore_error_keywords = []
+
+        filtered_issues = []
+        for issue in grammar_issues:
+            if issue['rule_id'] not in ignore_rule_ids and not any(keyword in issue['error'] for keyword in ignore_error_keywords):
+                filtered_issues.append(issue)
+        
+        return filtered_issues
+
+    def process_resume(self, text, found_keyword_section, Extract_sections):
+        sections_text = self.segregate_sections(text)
+        formatted_text = self.extract_and_format_sections(sections_text, Extract_sections)
+        found_keyword_section  = self.extract_keyword_variations_from_formatted_text(formatted_text)
+        placeholder_text, keyword_placeholders = self.replace_keywords_with_placeholders(formatted_text, found_keyword_section)
+        grammar_issues = self.grammar_check(placeholder_text)
+        grammar_issues_text = self.replace_placeholders_with_keywords(grammar_issues, keyword_placeholders)
+        filtered_grammar_issues = self.filter_grammar_issues(grammar_issues, ignore_rule_ids, ignore_error_keywords)
+        return {
+            "grammar_issues": filtered_grammar_issues,
+            "spelling_errors": [issue for issue in filtered_grammar_issues if "SPELLING" in issue['rule_id']]
+        }
+
+    def grammar_issue_check(self, text, found_keyword_section, Extract_sections):
+        issues = {}
+        text1 = " ".join(text.split("\n"))
+        for section in Extract_sections:
+            grammar_issues = self.process_resume(text, found_keyword_section, [section])
+            if not grammar_issues:
+                grammar_issues = "no error found"
+            issues[section] = grammar_issues
+        return issues
+    
+    def normalize_font_name(self,font_name):
+        if '-' in font_name:
+            font_name = font_name.split('-')[0]
+        if '+' in font_name:
+            font_name = font_name.split('+')[1]
+        return font_name
+
+    
+    def extract_text_properties(self, pdf_path, predefined_terms):
+        text_properties = []
+        current_phrase = ""
+        current_font_size = None
+        current_font_name = None
+        current_page_num = None
+
+        special_characters = set("●▪•!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~")
+
+        def add_current_phrase():
+            nonlocal current_phrase
+            if current_phrase.strip():
+                flag = any(current_phrase in term for term in predefined_terms)
+                if not flag:
+                    text_properties.append({
+                        "text": current_phrase,
+                        "font_size": current_font_size,
+                        "font_name": current_font_name,
+                        "page_num": current_page_num
+                    })
+                current_phrase = ""
+
+        for page_layout in extract_pages(pdf_path):
+            for element in page_layout:
+                if isinstance(element, LTTextContainer):
+                    for text_line in element:
+                        if isinstance(text_line, LTTextLineHorizontal):
+                            for character in text_line:
+                                if isinstance(character, LTChar):
+                                    text = character.get_text()
+                                    font_size = round(character.size, 2)
+                                    font_name = self.normalize_font_name(character.fontname)
+                                    page_num = page_layout.pageid
+
+                                    if text.isspace() or text in special_characters:
+                                        add_current_phrase()
+                                        continue
+
+                                    if (font_size != current_font_size or font_name != current_font_name or
+                                        page_num != current_page_num):
+                                        add_current_phrase()
+                                        current_font_size = font_size
+                                        current_font_name = font_name
+                                        current_page_num = page_num
+
+                                    current_phrase += text
+
+                            add_current_phrase()
+
+        return text_properties
+    
+    def group_similar_fonts(self,text_properties, tolerance=0.5):
+        grouped_properties = defaultdict(list)
+        
+        for prop in text_properties:
+            rounded_size = round(prop["font_size"] / tolerance) * tolerance
+            key = (prop["font_name"], rounded_size)
+            grouped_properties[key].append(prop)
+
+        return grouped_properties
+    
+
+
+
+    def identify_different_fonts_and_sizes(self, grouped_properties):
+        most_common_group = max(grouped_properties.values(), key=len)
+        most_common_key = None
+        for key, group in grouped_properties.items():
+            if group == most_common_group:
+                most_common_key = key
+                break
+
+        different_texts = []
+
+        for key, group in grouped_properties.items():
+            if group != most_common_group:
+                for prop in group:
+                    reason = []
+                    if key[1] != most_common_key[1]:
+                        reason.append(f"size not {most_common_key[1]}")
+                    if key[0] != most_common_key[0]:
+                        reason.append(f"font not {most_common_key[0]}")
+                    different_texts.append({
+                        "page_num": prop['page_num'],
+                        "text": prop['text'],
+                        "found_size": prop['font_size'],
+                        "found_font_name": prop['font_name'],
+                        "reason": ", ".join(reason)
+                    })
+
+        return different_texts
+    
+    def parse_dates(self, sections_text, section_name):
+            # Check if the  section is in the text
+        suggest = ""
+
+        # Define the date patterns to match various date formats
+        date_pattern = (
+            r'\b\d{1,2}/\d{4}\b|'  # MM/YYYY
+            r'\b(?: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{4}\b|'  # Month YYYY
+            r'\b(?: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{1,2},?\s*\d{4}\b|'  # Month DD, YYYY
+            r'\b\d{4}\b|'  # YYYY
+            r'\b(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)[a-z]*/?\d{4}\b|'  # Month/YYYY
+            r'\b(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)[a-z]*\d{4}\s*-\s*(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)[a-z]*\d{4}\b'  # Month/YYYY - Month/YYYY
+        )
+
+        all_dates = []
+
+        # Iterate over the entries in the section_name
+        for entry in sections_text[section_name]:
+            entry = entry.lower()
+            matches = re.findall(date_pattern, entry)
+            if matches and len(matches)>1:
+                if len(matches) == 2:
+                    all_dates.append(f"{matches[0]} {matches[1]}")
+                else:
+                    all_dates.extend(matches)
+
+        return all_dates
+
+
+    def convert_to_date(self, date_str):
+        # Mapping of month names and abbreviations to their numeric equivalents
+        month_map = {
+                'jan': 1, 'january': 1, 'feb': 2, 'february': 2,
+                'mar': 3, 'march': 3, 'apr': 4, 'april': 4,
+                'may': 5, 'jun': 6, 'june': 6, 'jul': 7,
+                'july': 7, 'aug': 8, 'august': 8, 'sep': 9,
+                'september': 9, 'oct': 10, 'october': 10,
+                'nov': 11, 'november': 11, 'dec': 12, 'december': 12,
+                '01': 1, '02': 2, '03': 3, '04': 4,
+                '05': 5, '06': 6, '07': 7, '08': 8,
+                '09': 9, '10': 10, '11': 11, '12': 12
+            }
+
+        # Regex patterns to match different date formats
+        pattern_mm_yyyy = re.compile(r'(\d{1,2})/(\d{4})')
+        pattern_mm_yyyy_space = re.compile(r'(\d{1,2})\s(\d{4})')
+        pattern_month_yyyy = re.compile(r'([a-zA-Z]+)\s?(\d{4})')
+        pattern_yyyy = re.compile(r'(\d{4})')
+
+        def extract_date(date_str):
+            match_mm_yyyy = pattern_mm_yyyy.match(date_str)
+            match_mm_yyyy_space = pattern_mm_yyyy_space.match(date_str)
+            match_month_yyyy = pattern_month_yyyy.match(date_str)
+            match_yyyy = pattern_yyyy.match(date_str)
+
+            if match_mm_yyyy:
+                month = int(match_mm_yyyy.group(1))
+                year = int(match_mm_yyyy.group(2))
+            elif match_mm_yyyy_space:
+                month = int(match_mm_yyyy_space.group(1))
+                year = int(match_mm_yyyy_space.group(2))
+            elif match_month_yyyy:
+                month = month_map.get(match_month_yyyy.group(1).lower())
+                year = int(match_month_yyyy.group(2))
+            elif match_yyyy:
+                month = 1
+                year = int(match_yyyy.group(1))
+            else:
+                return []
+
+            return datetime.date(year, month, 1)
+
+        date_parts = re.findall(r'(\d{4}\s[a-zA-Z]+\s?|\d{4}[a-zA-Z]+|\d{4}\/\d{2}|\d{4}\s\d{2}|[a-zA-Z]+\s?\d{4}|\d{4}\s[a-zA-Z]+)', date_str)
+        if len(date_parts) == 1:
+            # Standalone year or single date
+            start_date = extract_date(date_parts[0])
+            end_date = datetime.date(start_date.year, start_date.month, start_date.day)
+        elif len(date_parts) == 2:
+            # Date range
+            start_date = extract_date(date_parts[0])
+            end_date = extract_date(date_parts[1])
+        else:
+            return []
+
+        return start_date, end_date
+
+
+    def date_time(self, date_parts):
+        converted_dates = []
+        for date_part in date_parts:
+                start_date, end_date = self.convert_to_date(date_part)
+                converted_dates.append((start_date, end_date))
+        return converted_dates  
+    
+
+    def check_chronological_order(self, converted_dates, section_name ):
+        suggestion = ""
+        sorted_dates = sorted(converted_dates, key=lambda x: (x[1], x[0]), reverse=True)
+        if converted_dates == sorted_dates:
+            suggestion = f"{section_name} section is in chronological order."
+        else:
+            suggestion = f"{section_name} section is not in chronological order."
+
+        return suggestion
+    
+    def check_common_projects(self, projects_text):
+        found_projects = []
+        for project in common_projects:
+            if project.lower() in projects_text.lower():
+                found_projects.append(project)
+        return found_projects
+    
+    def recommend_resources():
+    # Randomly pick 2 blog articles and 2 YouTube links
+         recommended_blogs = random.sample(blog_articles, 2)
+         recommended_youtube = random.sample(youtube_links, 2)
+
+    # Return the recommendations
+         return {
+        "Recommended Blogs": recommended_blogs,
+        "Recommended YouTube Links": recommended_youtube
+    }
+    
+    def check_imarticus_certifications(self, certifications_text):
+    # Check if "imarticus" is present in the certifications text
+        if "imarticus" in certifications_text.lower():
+            return {
+               "found": True,
+               "message": "Imarticus certification found. Please upload it in the academic section."
+             }
+        return {
+           "found": False,
+           "message": "No Imarticus certification found in the provided text."
+            }
+
+
+    def chronological_order_check(self, sections_text, section_name):
+        order_suggestion = ""
+        suggestion = ""   
+        section_name = section_name.upper()
+        if section_name in sections_text:
+            date = self.parse_dates(sections_text, section_name)
+            if date:
+                converted_dates = self.date_time(date) 
+                order_suggestion = self.check_chronological_order(converted_dates, section_name)
+            else:
+                suggestion = f"No valid dates found in {section_name} section. "
+        else:
+            suggestion = f"{section_name} is not in section header. "
+        
+        return order_suggestion, suggestion
+
+    
+
+    # Function to check for spelling mistakes 
+    def check_spelling(self, headers, section_headers):
+        suggestions = []
+        for header in headers:
+            if header.upper() not in map(str.upper, section_headers):
+                suggestions = header
+        return suggestions
+
+    def is_present_name(name):
+       """
+         Checks if a given name has at least 2 words.
+
+       Args:
+         name: The name string to check.
+
+       Returns:
+          True if it has at least 2 words, false otherwise.
+       """
+       parts = name.split()
+       return len(parts) >= 2
+
+    def is_sentence_case(name):
+
+        parts = name.split()  # Split into individual words
+        for part in parts:
+            if not part:  # handles empty strings in name
+                continue
+            if not part[0].isupper() or not part[1:].islower():
+                return False  # Check if first letter is uppercase and rest are lowercase
+        return True
+
+    def is_present_name(self,name):
+        parts = name.split()
+        return len(parts) >= 2
+
+    def is_sentence_case(self,name):
+        parts = name.split()
+        for part in parts:
+            if not part:
+                continue
+            if not part[0].isupper() or not part[1:].islower():
+                return False
+        return True
+    
+    def extract_project_links(self,sections_text):
+        project_links = {}
+
+        if "PROJECTS" in sections_text:
+            project_list = sections_text.get("PROJECTS", [])
+            url_pattern = r"https?://[^\s]+"
+            for project in project_list:
+                links = re.findall(url_pattern,project)
+                if links:
+                    project_links[project] = links
+        return project_links
+            
+    def count_sentences(self,text):
+        sentence_endings = r"(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?|!)\s"
+        sentences = re.split(sentence_endings, text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        return len(sentences)
+    
+    def calculate_summary_score(self, summary):
+        score = 0  # Initialize score
+        if not summary:
+            return score
+        
+        num_sentences = self.count_sentences(summary)
+        if num_sentences <= 2:
+            return 2
+        elif num_sentences > 2 and num_sentences <= 4:
+            return 3
+        elif num_sentences > 4:
+            return 5
+        else:
+            return 0
+
+    def calculate_extra_urls_bonus(self,pdf_path):
+        domains = [
+            r"hackerrank\.com",  # Hackerrank
+            r"leetcode\.com",    # LeetCode
+            r"medium\.com"       # Medium
+        ]
+        extra_urls = self.extract_extra_urls_pdf(pdf_path, domains)
+        has_extra_urls = any(urls for urls in extra_urls.values())
+        return 5 if has_extra_urls else 0
+    
+    def calculate_relevant_experience_score(self, experience_text):
+        """
+        Assigns a score based on the presence of relevant experience keywords.
+
+        Args:
+            experience_text (str): The extracted work experience section text.
+
+        Returns:
+            int: A score of 5 if relevant keywords are found, otherwise 0.
+        """
+        if not experience_text:
+            return 0  # ✅ No experience section → Score 0
+
+        if isinstance(experience_text, list):
+            experience_text = " ".join(experience_text)  # ✅ Convert list to a single string
+        
+        experience_text = experience_text.strip().lower()  # ✅ Ensure it's a string and lowercase
+
+        # ✅ Check if any keyword from 'data_science_skills' or 'essential_skills' exists
+        for skill in config.data_science_skills + config.essential_skills:
+            if skill.lower() in experience_text:
+                return 5  # ✅ Found relevant experience → Full score
+
+        return 0
+        
+    def calculate_ds_skills_score(self, skills_present):
+        if not skills_present:  # No skills found at all
+            return 0
+        
+        # Use skills from config instead of hardcoded list
+        ds_skills_list_lower = [skill.lower() for skill in config.data_science_skills]
+        skills_present_lower = [skill.lower() for skill in skills_present]
+
+        matching_count = sum(1 for skill in skills_present_lower 
+                            if skill in ds_skills_list_lower)
+
+        if matching_count == 0:  # Skills found but none match DS list
+            return 2
+        elif 1 <= matching_count <= 5:
+            return 3
+        elif matching_count > 5:
+            return 5
+        return 0
+    
+    def calculate_project_link_score(self, projects_with_links):    
+        """
+        Assigns a score based on whether project links are present.
+
+        Args:
+            projects_with_links (int): The number of projects with links.
+
+        Returns:
+            int: 2 if project links are found, otherwise 0.
+        """
+        return 2 if projects_with_links > 0 else 0
+
+
+    def imarticus_review_score(self,name,contact_number,email,linkedin_urls,github_url,missing_sections,sections_not_capitalized,common_projects,section_order_suggestion,sections_text,skills,relevant_experience_score):
+        score = 0
+        if name:
+            name_parts = name.split()
+            num_parts = len(name_parts)
+
+            if num_parts == 0:
+                score += 0
+            if self.is_sentence_case(name):
+                score += 3
+            elif self.is_present_name(name):
+                score += 1.5
+        
+        if contact_number and isinstance(contact_number, str):
+            digits_only = re.sub(r'\D', '', contact_number)
+
+            if digits_only.startswith("91") and len(digits_only) > 10:
+                digits_only = digits_only[2:]  # Remove the first two characters ('91')
+
+            if len(digits_only) == 10 and digits_only[0] in "6789":  # Check for valid Indian mobile numbers
+                score += 3
+
+        if email:
+            score += 3 if self.is_valid_email(email) else 0
+
+        score += 3 if linkedin_urls else 0
+
+        if github_url:
+            github_suggestion = self.is_valid_url(github_url)
+            score += 3 if not github_suggestion else 0
+        else:
+            score += 0
+
+        if len(missing_sections)==0 and len(sections_not_capitalized)==0:
+            score+=10
+        elif len(missing_sections)==0 and len(sections_not_capitalized)>0:
+            score+=8
+        elif len(missing_sections)<=3:
+            score+=6
+        elif len(missing_sections)>4:
+            score+=3
+
+        if common_projects:
+            score +=0
+        else:
+            score +=5
+
+        if section_order_suggestion:
+            score -= 2
+        else:
+            score
+        
+        """
+        ds_skills_list_lower = [skill.lower() for skill in data_science_skills]
+        skills_present_lower = [skill.lower() for skill in self.extract_skills_from_resume(skills) ]
+
+        matching_skill_count = 0
+        for skill in skills_present_lower:
+            if ds_skills_list_lower:
+                matching_skill_count+=1
+        if  matching_skill_count==0:
+            score+=0
+        
+        if matching_skill_count<=5:
+            score+=2
+        elif matching_skill_count>=10 and matching_skill_count<=15:
+            score+5
+        else:
+            score+=8
+       """
+        
+        if "PROJECTS" not in sections_text:
+            score+=0
+        else:
+            project_list = sections_text.get("PROJECTS",[])
+            project_count = len([x for x in project_list if "Description" in x])
+
+            if project_count<=2:
+                score+=2
+            elif project_count>2 and project_count<=4:
+                score+=5
+            elif project_count>4:
+                score+=3
+
+                
+        resume_data = {}        
+        # Extract projects & links
+        project_links = self.extract_project_links(sections_text)
+        projects_with_links = len(project_links)
+
+        # ✅ Count only projects with descriptions
+        valid_projects = [
+            p for p in sections_text.get("PROJECTS", []) if "description" in p.lower()
+        ]
+        total_projects = len(valid_projects)  # ✅ Count projects properly
+
+        # ✅ Calculate project link score
+        project_link_score = self.calculate_project_link_score(projects_with_links)
+        resume_data["project_link_score"] = project_link_score
+
+        # ✅ Prevent division by zero
+        if total_projects > 0:
+            if projects_with_links == 0:
+                score += 0
+            elif projects_with_links / total_projects >= 0.5:
+                score += 1.5
+            if projects_with_links == total_projects:
+                score += 3
+        else:
+            score += 0  # ✅ Ensure no division error if no projects exist
+
+            
+        """"
+        profile_summary = sections_text.get("PROFILE SUMMARY", "")
+        print(profile_summary)
+
+        summary_score = self.calculate_summary_score(profile_summary)
+        score += summary_score 
+        """
+        ds_skills_score = self.calculate_ds_skills_score(skills)
+        score += ds_skills_score
+
+        certifications = sections_text.get("CERTIFICATIONS & ACADEMIC ENDEAVOURS", [])
+        num_certifications = len(certifications)
+
+        if num_certifications==0:
+            score+=0
+        elif 0 < num_certifications <= 2:
+            score+=3
+        elif 2 < num_certifications <= 4:
+            score+=5
+        elif num_certifications>4:
+            score+=7
+        """
+        extra_urls_bonus = self.calculate_extra_urls_bonus(pdf_path)
+        score += extra_urls_bonus
+        """
+        score += relevant_experience_score
+
+        score += project_link_score 
+
+        return score
+    
+
+    def imarticus_detailed_score(self, name, contact_number, email, linkedin_urls, github_url, 
+                            missing_sections=None, sections_not_capitalized=None, common_projects=None, 
+                            section_order_suggestion=None, sections_text=None, skills=None, 
+                            relevant_experience_score=0):
+        
+        # Ensure lists and dictionaries have default values to avoid 'NoneType' errors
+        missing_sections = missing_sections or []
+        sections_not_capitalized = sections_not_capitalized or []
+        common_projects = common_projects or []
+        sections_text = sections_text or {}
+
+        score_breakdown = {
+            "name_score": 0,
+            "contact_number_score": 0,
+            "email_score": 0,
+            "linkedin_url_score": 0,
+            "github_url_score": 0,
+            "missing_sections_score": 0,
+            "common_projects_score": 0,
+            "section_order_score": 0,
+            "projects_score": 0,
+            "certifications_score": 0,
+            "relevant_experience_score": 0,
+            "ds_skills_score": 0,
+            "extra_urls_bonus": 0,
+            "summary_score": 0,
+            "project_link_score": 0
+        }
+
+        # ✅ Name Score (3 Points)
+        if name:
+            if self.is_sentence_case(name):
+                score_breakdown["name_score"] = 3
+            elif self.is_present_name(name):
+                score_breakdown["name_score"] = 1.5
+
+        # ✅ Contact Number Score (3 Points)
+        if contact_number and isinstance(contact_number, str):
+            digits_only = re.sub(r'\D', '', contact_number)
+            if digits_only.startswith("91") and len(digits_only) > 10:
+                digits_only = digits_only[2:]
+            if len(digits_only) == 10 and digits_only[0] in "6789":  
+                score_breakdown["contact_number_score"] = 3  
+
+        # ✅ Email Score (3 Points)
+        score_breakdown["email_score"] = 3 if email and self.is_valid_email(email) else 0
+
+        # ✅ LinkedIn URL Score (3 Points)
+        score_breakdown["linkedin_url_score"] = 3 if linkedin_urls else 0
+
+        # ✅ GitHub URL Score (3 Points)
+        if github_url and self.is_valid_url(github_url):
+            score_breakdown["github_url_score"] = 3
+
+        # ✅ Missing Sections Score (10 Points)
+        if not missing_sections and not sections_not_capitalized:
+            score_breakdown["missing_sections_score"] = 10
+        elif not missing_sections and sections_not_capitalized:
+            score_breakdown["missing_sections_score"] = 8
+        elif len(missing_sections) <= 3:
+            score_breakdown["missing_sections_score"] = 6
+        else:
+            score_breakdown["missing_sections_score"] = 3
+
+        # ✅ Common Projects Score (5 Points)
+        score_breakdown["common_projects_score"] = 0 if common_projects else 5
+
+        # ✅ Section Order Score (2 Points)
+        score_breakdown["section_order_score"] = -2 if section_order_suggestion else 0
+
+        # ✅ Projects Score (5 Points)
+        if "PROJECTS" in sections_text:
+            project_list = sections_text.get("PROJECTS", [])
+            project_count = len([x for x in project_list if "Description" in x])
+            if project_count <= 2:
+                score_breakdown["projects_score"] = 2
+            elif 2 < project_count <= 4:
+                score_breakdown["projects_score"] = 5
+            else:
+                score_breakdown["projects_score"] = 3
+
+        # ✅ Certifications Score (7 Points)
+        certifications = sections_text.get("CERTIFICATIONS & ACADEMIC ENDEAVOURS", [])
+        num_certifications = len(certifications)
+        if num_certifications == 0:
+            score_breakdown["certifications_score"] = 0
+        elif 0 < num_certifications <= 2:
+            score_breakdown["certifications_score"] = 3
+        elif 2 < num_certifications <= 4:
+            score_breakdown["certifications_score"] = 5
+        else:
+            score_breakdown["certifications_score"] = 7
+
+        # ✅ Relevant Experience Score (5 Points)
+        score_breakdown["relevant_experience_score"] = relevant_experience_score if relevant_experience_score is not None else 0
+
+        # ✅ Data Science Skills Score (5 Points)
+        score_breakdown["ds_skills_score"] = self.calculate_ds_skills_score(skills)
+
+        # ✅ Extra URLs Bonus (5 Points)
+        score_breakdown["extra_urls_bonus"] = self.calculate_extra_urls_bonus(sections_text)
+
+        # ✅ Summary Score (5 Points)
+        profile_summary = sections_text.get("PROFILE SUMMARY", "")
+        score_breakdown["summary_score"] = self.calculate_summary_score(profile_summary)
+
+        # ✅ Project Link Score (2 Points)
+        project_links = self.extract_project_links(sections_text)
+        projects_with_links = len(project_links)
+        score_breakdown["project_link_score"] = self.calculate_project_link_score(projects_with_links)
+
+        return score_breakdown
+            
+    def parse_text(self, path):
+        logger = logging.getLogger(__name__)
+        logging.getLogger("pdfminer").setLevel(logging.WARNING)
+        resume_data = {}
+        logger.debug('parsing text')
+        text = self.extract_text_from_pdf(path)
+        text1 = " ".join(text.split("\n"))
+        skills_found = self.extract_skills_from_resume(text)
+        found_keywords = self.extract_keyword_variations_from_resume(text)
+        sections_text = self.segregate_sections(text)
+        formatted_text = self.extract_and_format_sections(sections_text, Extract_sections)
+        found_keyword_section = self.extract_keyword_variations_from_formatted_text(formatted_text)
+
+        parsed_sections = self.segregate_sections(text)
+        projects = parsed_sections.get("PROJECTS", [])
+        certifications = parsed_sections.get("CERTIFICATIONS & ACADEMIC ENDEAVOURS", [])
+        projects_text = "\n".join(projects)
+        certifications_text = "\n".join(certifications)
+        found_imarticus_certification = self.check_imarticus_certifications(certifications_text)
+        found_projects = self.check_common_projects(projects_text)
+
+        name, name_suggestion = self.extract_name(text)
+        contact_number, contact_suggestion = self.extract_contact_number_from_resume(text)
+        email, email_suggestion = self.extract_email_from_resume(path)
+        github_urls =  self.extract_github_urls_from_pdf(path)     
+        github_urls_suggestions = self.is_valid_url(github_urls)
+        linkedin_urls =  self.extract_linkedIn_urls_from_pdf(path)
+        section_by_grammer_issues = self.grammar_issue_check(text, found_keyword_section, Extract_sections)
+        
+
+        domains = [
+         r"hackerrank\.com",  # Hackerrank
+         r"leetcode\.com",    # LeetCode
+         r"medium\.com"       # Medium
+          ]
+        extra_urls = self.extract_extra_urls_pdf(path, domains)
+
+        education_order_suggestion, education_suggestion = self.chronological_order_check(sections_text, "ACADEMIC PROFILE")
+        experience_order_suggestion, experience_suggestion = self.chronological_order_check(sections_text, "WORK EXPERIENCE")   
+
+        headers = list(sections_text.keys())        
+        spelling_suggestions = self.check_spelling(headers, section_headers)
+
+        predefined_terms = [name, email]
+        predefined_terms.extend(required_sections)
+        text_properties = self.extract_text_properties(path, predefined_terms)
+        grouped_properties = self.group_similar_fonts(text_properties)
+        different_texts = self.identify_different_fonts_and_sizes(grouped_properties)
+
+        font_suggestions = []
+        for item in different_texts:
+            font_suggestion = f"Formatting issue at Page: {item['page_num']}, Text: {item['text']}, Reason: {item['reason']}, Found font size: {item['found_size']}, Found font name: {item['found_font_name']}"
+            font_suggestions.append(font_suggestion)
+
+        missing_sections, sections_not_capitalized = self.extract_sections_from_resume(text)
+
+        linkedin_urls_suggestion = str()
+        common_project = str()
+        if not name:
+            name_suggestion = "Please add  name to the resume."
+        if not contact_number:
+            contact_suggestion = "Please add the contact number to the resume."
+        if not email:
+            email_suggestion = "Please add the email address to the resume."
+        if not github_urls:
+            github_urls_suggestions = "add the github_urls to the resume."
+        if not linkedin_urls:
+            linkedin_urls_suggestion = "add the linkedin_urls to the resume."
+        if found_projects:
+            common_project = "Common projects found in Projects section: "
+            for project in found_projects:
+                common_project += project
+
+        # Replace the existing project length suggestion code with:
+        project_list = sections_text.get("PROJECTS", [])
+        projects_with_description = [
+            p for p in project_list 
+            if "description" in p.lower()
+        ]
+        project_count = len(projects_with_description)
+
+        if project_count == 0:
+            project_length_suggestion = "No projects found. Consider at least 2 projects."
+        elif project_count == 1:
+            project_length_suggestion = "Only 1 project found. Consider adding 1 more project."
+        else:
+            project_length_suggestion = f"{project_count} projects found."
+
+        # Store in resume data (keeps your existing URL extraction)
+        resume_data["project_length_suggestion"] = project_length_suggestion
+
+        experience_text = sections_text.get("WORK EXPERIENCE", "")  # ✅ Extract work experience section
+        relevant_experience_score = self.calculate_relevant_experience_score(experience_text)  # ✅ Calculate score
+
+        # ✅ Store in the final resume data output
+        resume_data["relevant_experience_score"] = relevant_experience_score
+
+
+        recommended_blogs = random.sample(blog_articles, 2)
+        recommended_youtube = random.sample(youtube_links, 2)
+
+    # Calculate imarticus_score
+        imarticus_score = self.imarticus_review_score(  
+        name, 
+        contact_number,
+        email,
+        linkedin_urls,
+        github_urls,  
+        missing_sections, 
+        sections_not_capitalized,
+        common_projects=found_projects,  # Ensure to pass found projects
+        section_order_suggestion=experience_order_suggestion,
+        skills=skills_found,  # Pass order suggestion
+        sections_text=sections_text,
+        relevant_experience_score=relevant_experience_score,
+        # project_link_score=project_link_score
+        #pdf_path=path
+        #relevant_keywords_found=bool(found_keywords),  # Convert to boolean
+        #experience_orderly_arranged=experience_order_suggestion,  # Pass orderly arrangement check
+        #experience_section_present="WORK EXPERIENCE" in sections_text  # Check if experience section is present
+    )
+
+    # Populate resume data dictionary
+        resume_data = {
+        "name": name,
+        "contact_number": contact_number,
+        "email": email,
+        "linkedin_urls": linkedin_urls,
+        "experience_order_suggestion": experience_order_suggestion,
+        "education_order_suggestion": education_order_suggestion,
+        "grammer_issues_by_section": section_by_grammer_issues,
+        "github_urls": github_urls,
+        "skills": skills_found,
+        "spelling_suggestions": spelling_suggestions,
+        "found_keywords": found_keywords,
+        "text": text,
+        "font_suggestions": font_suggestions,
+        "name_suggestion": name_suggestion,
+        "contact_suggestion": contact_suggestion,
+        "email_suggestion": email_suggestion,
+        "imarticus_score": imarticus_score,
+        "github_urls_suggestions": github_urls_suggestions,
+        "linkedin_urls_suggestion": "Add the LinkedIn URLs to the resume." if not linkedin_urls else "",
+        "missing_sections": missing_sections,
+        "common_projects": "Common projects found in Projects section: " + ", ".join(found_projects) if found_projects else "",
+        "project_length_suggestion": project_length_suggestion,
+        "extra_urls": extra_urls,
+        "certifications": {
+            "found": found_imarticus_certification["found"],
+            "message": found_imarticus_certification["message"],
+            "text": certifications_text  # Store extracted certification text
+        },
+        "recommended_blogs": recommended_blogs,  
+        "recommended_youtube_links": recommended_youtube
+    }
+
+    # Additional checks and data additions
+        if "WORK EXPERIENCE" in sections_text.keys() and "WORK EXPERIENCE" != list(sections_text.keys())[2]:
+            section_order_suggestion = f"WORK EXPERIENCE should come before {list(sections_text.keys())[2]}"
+            resume_data["section_order_suggestion"] = section_order_suggestion
+
+        missing_important_sections = self.check_missing_sections(resume_data)
+        resume_data["basic_information_section"] = missing_important_sections or "Basic information is Found"
+
+        missing_skills = list(set(essential_skills) - set(skills_found))
+        resume_data["missing_skills"] = missing_skills
+
+        found_keywords_count = len(resume_data["found_keywords"])
+        num_keywords = len(keyword_variations)
+        quality_mapping = {"Low": 0.2, "Medium": 0.5, "High": 0.8}  # Assuming some quality mapping
+        for quality, threshold in quality_mapping.items():
+            if found_keywords_count < num_keywords * threshold:
+                resume_data["quality"] = quality
+                break
+
+        found_certification = "Imarticus certification found in Certifications section." if found_imarticus_certification else "No Imarticus certification found in Certifications section."
+        resume_data["found_certification"] = found_certification
+
+        # Experience relevance check
+        Extract_exp_sections = ['WORK EXPERIENCE']
+        experience_text = self.extract_and_format_sections(sections_text, Extract_exp_sections)
+        if experience_text:
+            resume_data["work_experience_check"] = "Experience is relevant to Data science." if any(variation.lower() in experience_text.lower() for keyword, variations in keyword_variations.items() for variation in variations) else "Experience is not relevant to Data science."
+
+        return jsonify(resume_data)

src/reviewer.py

@@ -0,0 +1,84 @@
+import language_tool_python  
+import re  
+
+class ResumeReviewer:
+    def __init__(self):
+        self.tool = language_tool_python.LanguageTool('en-US')  
+
+    def grammar_check(self, parsed_resume):
+        if not parsed_resume:
+            return {}, 3  # ✅ Return empty dictionary and high grammar score
+
+        section_wise_issues = {}
+        total_grammar_errors = 0  
+        total_words = 0  
+        grammar_score = 0  
+
+        ignore_keywords = {"imarticus", "github", "linkedin", "microsoft office", "google drive", "amazon web services"}
+        ignore_rule_ids = {"WHITESPACE_RULE", "EN_QUOTES", "CONSECUTIVE_SPACES", "UPPERCASE_SENTENCE_START"}  # ✅ Ignore false uppercase errors
+
+        ignore_patterns = [
+            r'\d+',  # Ignore standalone numbers
+            r'https?://\S+',  # Ignore URLs
+            r'\S+@\S+',  # Ignore emails
+            r'^\s*[-•]+\s*',  # ✅ Ignore bullet points
+        ]
+
+        name_to_exclude = parsed_resume.get("name", "").strip().lower()
+
+        for section, text in parsed_resume.items():
+            if isinstance(text, str) and text.strip():
+                words_in_section = len(text.split())  
+                total_words += words_in_section
+
+                matches = self.tool.check(text)  
+                grammar_issues = []
+                spelling_errors = []
+
+                for match in matches:
+                    context_text = match.context.lower()
+
+                    # ✅ Ignore rule-based exclusions
+                    if match.ruleId in ignore_rule_ids or any(keyword in context_text for keyword in ignore_keywords):
+                        continue  
+                    if name_to_exclude and name_to_exclude in context_text:
+                        continue  
+                    if any(re.search(pattern, match.context) for pattern in ignore_patterns):
+                        continue  
+                    
+                    # ✅ Ignore false uppercase errors caused by bullet points
+                    if "sentence does not start with an uppercase letter" in match.message.lower() and re.search(r'^\s*[-•]+\s*', match.context):
+                        continue  
+
+                    issue = {
+                        "context": match.context,
+                        "error": match.message,
+                        "rule_id": match.ruleId,
+                        "suggested_correction": match.replacements
+                    }
+
+                    # ✅ Separate grammar and spelling errors
+                    if "SPELL" in issue.get("rule_id", ""):
+                        spelling_errors.append(issue)
+                    else:
+                        grammar_issues.append(issue)
+                        total_grammar_errors += 1  
+
+                if grammar_issues or spelling_errors:
+                    section_wise_issues[section] = {
+                        "grammar_issues": grammar_issues,
+                        "spelling_errors": spelling_errors
+                    }
+
+        # ✅ Calculate mistake percentage
+        mistake_percentage = (total_grammar_errors / total_words) * 100 if total_words > 0 else 0
+
+        # ✅ Apply scoring logic from Excel
+        if total_grammar_errors == 0:
+            grammar_score = 3  
+        elif mistake_percentage < 50:
+            grammar_score = 2  
+        else:
+            grammar_score = 1  
+
+        return section_wise_issues, grammar_score  # ✅ Always returns 2 values

src/submitter.py

@@ -0,0 +1,32 @@
+import os
+from .config import UPLOAD_FOLDER, ALLOWED_EXTENSIONS
+from flask import render_template, redirect, flash, request, url_for
+from werkzeug.utils import secure_filename
+
+class ResumeSubmitter:
+    def __init__(self):
+        if not os.path.exists(UPLOAD_FOLDER):
+            os.makedirs(UPLOAD_FOLDER)
+
+    def allowed_file(self, filename):
+        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+    def upload_form(self):
+        return render_template("upload_resume.html")
+
+    def upload_file(self):
+        if 'file' not in request.files:
+            return 'No file part'
+        
+        file = request.files['file']
+        if file.filename == '':
+            return 'No selected file'
+        
+        if file and self.allowed_file(file.filename):
+            filename = secure_filename(file.filename)
+            file.save(os.path.join(UPLOAD_FOLDER, filename))
+            flash('File successfully uploaded')
+            # return file path
+            return os.path.join(UPLOAD_FOLDER, filename)
+        else:
+            return "Allowed file types are PDF as of now"