uploading files

.env

@@ -0,0 +1,2 @@
+
+GOOGLE_API_KEY = AIzaSyAYUaHLg1cA80tog1IBIjFF1P8bBjpoT1w

app.py

@@ -0,0 +1,99 @@
+import streamlit as st
+import google.generativeai as genai
+from dotenv import load_dotenv
+load_dotenv()
+import re
+import time
+import os
+
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+
+model = genai.GenerativeModel("gemini-pro")
+
+
+chat = model.start_chat(
+    history=[
+        {"role": "user", "parts": "Hello"},
+        {"role": "model", "parts": "Great to meet you. What would you like to know?"},
+    ]
+)
+
+
+def generate_questions(chat, tech):
+    """Generates 3-5 technical questions for a specific tech item, starting from easy to advanced."""
+    prompt = (
+        f"You are a technical interviewer. Create 3 to 5 technical interview questions for the technology: {tech}. "
+        "Don't mention level of question and just provide the questions directly."
+        
+    )
+    open_ended_response = chat.send_message(prompt, stream=True)
+    open_ended_response.resolve()
+    open_ended= open_ended_response.text if open_ended_response.text else "Unable to generate open-ended questions."
+    # print(open_ended)
+    return  open_ended
+
+
+
+
+
+# Streamlit UI
+st.title("TalentScout - Hiring Assistant Chatbot")
+st.sidebar.title("Candidate Details")
+
+# Collect Candidate Information
+with st.sidebar.form("candidate_form"):
+    name = st.text_input("Full Name")
+    email = st.text_input("Email Address")
+    phone = st.text_input("Phone Number")
+    experience = st.number_input("Years of Experience", min_value=0, step=1)
+    position = st.text_input("Desired Position")
+    location = st.text_input("Current Location")
+    tech_stack = st.text_area("Tech Stack (comma-separated)").split(",")
+    submit = st.form_submit_button("Submit")
+
+if submit:
+    st.success("Candidate information submitted successfully!")
+
+    # Display Candidate Information
+    st.write("### Candidate Information")
+    st.write(f"**Name:** {name}")
+    st.write(f"**Email:** {email}")
+    st.write(f"**Phone:** {phone}")
+    st.write(f"**Experience:** {experience} years")
+    st.write(f"**Position:** {position}")
+    st.write(f"**Location:** {location}")
+    st.write(f"**Tech Stack:** {', '.join(tech_stack)}")
+    
+    
+
+    # Interactive Question and Answer Section
+    st.write("### Technical Questions")
+    all_answers = []
+
+    if tech_stack:
+        for tech in tech_stack:
+            tech = tech.strip()
+    
+            if tech:
+
+                st.write(f"**Questions for {tech}:**")
+                questions = generate_questions(chat, tech[:5])
+                for idx, question in enumerate(questions.split("\n\n")):
+                    st.write(f"{question.strip("\n")}")
+                    
+                    answer = st.text_area(f"Answer for Q{idx+1} ({tech})", key=f"answer_{tech}_{idx}")
+                    all_answers.append({"question": question, "answer": answer})
+        # Final Submission Button
+        if  st.button("Submit All Answers"):
+           
+            st.write("### Thank You for Completing the Questions!")
+            st.write("We appreciate your time and effort in answering the questions.")
+            st.write("Our team will review your responses and get back to you shortly.")
+            st.write("Warm regards,\nTalentScout Team")
+    else:
+        st.error("Please provide a valid tech stack.")
+
+# Exit Conversation
+# if st.button("End Conversation"):
+#     st.write("Thank you for using TalentScout! Best of luck to the candidates.")
+#     st.stop()

components/manual_entry.py

@@ -0,0 +1,66 @@
+from src.manual_entry import ManualEntry
+import streamlit as st
+from generate_questions.questions_generator import QuestionGenerator
+import google.generativeai as genai
+import os
+from src.feedback import feed_back
+from src.greetings import end_conversation, home_greetings
+import json
+
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+model = genai.GenerativeModel("gemini-pro")
+
+chat = model.start_chat(history=[])
+manual_entry = ManualEntry()
+questions_generator= QuestionGenerator()
+
+                            
+class EnterManually:
+    def manual_entry(self):
+        tech_stack = manual_entry.manual_entry_form()
+        if tech_stack:
+            st.session_state.tech_stack = tech_stack
+
+        if "questions" not in st.session_state:
+            st.session_state.questions = {}
+        if "answers" not in st.session_state:
+            st.session_state.answers = {}
+
+        if st.session_state.tech_stack:
+            if st.button("Generate Questions"):
+                for tech in st.session_state.tech_stack:
+                    if tech.strip() not in st.session_state.questions:
+                        questions = questions_generator.generate_questions(chat, tech)
+                        st.session_state.questions[tech] = questions.split("\n")
+                        st.session_state.answers[tech] = [""] * len(st.session_state.questions[tech])
+
+            if st.session_state.questions:
+                for tech, questions in st.session_state.questions.items():
+                    st.write(f"### Technical Questions for {tech}")
+                    for idx, question in enumerate(questions):
+                        st.write(f"{idx + 1}. {question}")
+                        st.session_state.answers[tech][idx] = st.text_area(
+                            f"Answer for Q{idx + 1} ({tech})",
+                            value=st.session_state.answers[tech][idx],
+                            key=f"answer_{tech}_{idx}",
+                        )
+
+                if st.button("Submit Answers"):
+                    greets = end_conversation()
+                    st.write(greets)
+                    output_data = []
+                    for tech, questions in st.session_state.questions.items():
+                        for idx, question in enumerate(questions):
+                            output_data.append({
+                                "tech": tech,
+                                "question": question,
+                                "answer": st.session_state.answers[tech][idx]
+                            })
+
+                    # Save as JSON file
+                    json_filename = "questions_answers.json"
+                    with open(json_filename, "w") as json_file:
+                        json.dump(output_data, json_file, indent=4)
+                    
+                feed_back()
+        

components/resume_entry.py

@@ -0,0 +1,83 @@
+import streamlit as st
+from src.resume_parser import ResumeParser
+from generate_questions.questions_generator import QuestionGenerator
+import google.generativeai as genai
+import os
+from src.greetings import end_conversation,start_greeting
+import json
+from src.feedback import feed_back
+
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+model = genai.GenerativeModel("gemini-pro")
+
+chat = model.start_chat(history=[])
+resume_parser = ResumeParser()
+questions_generator = QuestionGenerator()
+
+
+class ResumeUploader:
+    def resume_upload(self):
+        st.title("TalentScout - Hiring Assistant Chatbot")
+        start_greeting()
+        st.sidebar.title("Candidate Details")
+
+        if "tech_stack" not in st.session_state:
+            st.session_state.tech_stack = []
+        if "questions" not in st.session_state:
+            st.session_state.questions = {}
+        if "answers" not in st.session_state:
+            st.session_state.answers = {}
+
+        uploaded_file = st.sidebar.file_uploader("Upload Resume (PDF):", type=["pdf"])
+        if uploaded_file:
+            candidate_details = resume_parser.parse(uploaded_file)
+            st.success("Resume uploaded and processed successfully!")
+            st.write("### Candidate Information")
+            st.write(f"**Name:** {candidate_details['name']}")
+            st.write(f"**Email:** {candidate_details['email']}")
+            st.write(f"**Phone:** {candidate_details['phone']}")
+            st.write(f"**Experience:** {candidate_details['experience']}")
+            st.write(f"**Position:** {candidate_details['position']}")
+            st.write(f"**Location:** {candidate_details['location']}")
+            st.write(f"**Tech Stack:** {', '.join(candidate_details['tech_stack'])}")
+            st.session_state.tech_stack = candidate_details["tech_stack"][:5]
+
+        if st.session_state.tech_stack:
+            st.write("**Based on your Top 5 skills ,we generate Technical Question , you need to answer the question .If you are ready  please click Generate Questions button**")
+            if st.button("Generate Questions"):
+                for tech in st.session_state.tech_stack:
+                    tech = tech.strip()
+                    if tech not in st.session_state.questions:
+                        questions = questions_generator.generate_questions(chat, tech)
+                        st.session_state.questions[tech] = questions.split("\n")
+                        st.session_state.answers[tech] = [""] * len(st.session_state.questions[tech])
+
+            # Display questions and answers
+            if st.session_state.questions:
+                for tech, questions in st.session_state.questions.items():
+                    st.write(f"### Technical Questions for {tech}")
+                    for idx, question in enumerate(questions):
+                        st.write(f"{idx + 1}. {question}")
+                        st.session_state.answers[tech][idx] = st.text_area(
+                            f"Answer for Q{idx + 1} ({tech})",
+                            value=st.session_state.answers[tech][idx],
+                            key=f"answer_{tech}_{idx}",)
+
+                if st.button("Submit Answers"):
+                    # Combine questions and answers into a JSON format
+                    greets = end_conversation()
+                    st.write(greets)
+                    output_data = []
+                    for tech, questions in st.session_state.questions.items():
+                        for idx, question in enumerate(questions):
+                            output_data.append({
+                                "tech": tech,
+                                "question": question,
+                                "answer": st.session_state.answers[tech][idx]
+                            })
+
+                    # Save as JSON file
+                    json_filename = "questions_answers.json"
+                    with open(json_filename, "w") as json_file:
+                        json.dump(output_data, json_file, indent=4)
+                feed_back()

generate_questions/questions_generator.py

@@ -0,0 +1,32 @@
+import streamlit as st
+import google.generativeai as genai
+from dotenv import load_dotenv
+load_dotenv()
+import os
+from prompts.prompts import PromptGenerator
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+
+model = genai.GenerativeModel("gemini-pro")
+
+
+chat = model.start_chat(
+    history=[
+        {"role": "user", "parts": "Hello"},
+        {"role": "model", "parts": "Great to meet you. What would you like to know?"},
+    ]
+)
+
+class QuestionGenerator:
+    def generate_questions(self,chat, tech):
+        """Generates 3-5 technical questions for a specific tech item, starting from easy to advanced."""
+        # prompt = (
+        #     f"You are a technical interviewer. Create 3 to 5 technical interview questions for the technology: {tech}. "
+        #     "Don't mention level of question and just provide the questions directly."
+            
+        # )
+        prompt = PromptGenerator().get_prompts(tech)
+        open_ended_response = chat.send_message(prompt, stream=True)
+        open_ended_response.resolve()
+        open_ended= open_ended_response.text if open_ended_response.text else "Unable to generate open-ended questions."
+        # print(open_ended)
+        return  open_ended

main.py

@@ -0,0 +1,39 @@
+from components.resume_entry import ResumeUploader
+import streamlit as st
+from src.greetings import end_conversation,start_greeting
+from components.manual_entry import EnterManually
+from src.feedback import feed_back
+from src.home_page import home_ui, about_me
+
+
+# run_main()
+import streamlit as st
+from streamlit_option_menu import option_menu
+with st.sidebar:
+    selected = option_menu(
+        menu_title="Main Menu",
+        options=["Home", "Resume Uploader", "Manual Enter","About Me"],
+        icons=["house", "app-indicator", "bar-chart","person-video" ],
+        menu_icon="cast",
+        default_index=1,)
+if selected == "Home":
+    home_ui()
+if selected == "Resume Uploader":
+    resume_uploader = ResumeUploader()
+    greets =resume_uploader.resume_upload()
+    if greets:
+        st.write(greets)
+        # feed_back()
+
+if selected == "Manual Enter":
+    st.title("TalentScout - Hiring Assistant Chatbot")
+    start_greeting()
+    enter_manually = EnterManually()
+    greets = enter_manually.manual_entry()
+    if greets:
+        st.write(greets)
+        # feed_back()
+
+if selected == "About Me":
+    about_me()
+

prompts/prompts.py

@@ -0,0 +1,19 @@
+
+import streamlit as st
+class PromptGenerator:
+    def get_prompts(self, tech):
+        
+        prompt = (
+        f"You are a technical interviewer. Create 3 to 5 technical interview questions for the technology: {tech}. "
+        "Don't mention level of question and just provide the questions directly."
+        
+    )
+        return prompt
+    def evaluate_prompt(self):
+        evaluation_prompt = """
+Evaluate each answer based on accuracy, relevance, and clarity. If an answer is provided, assess it; if not, mark it as "No answer provided." After evaluating all answers, return the percentage of valid answers (answers that are accurate, relevant, and clear).
+"""
+        
+        return evaluation_prompt
+
+

requirements.txt

@@ -0,0 +1,90 @@
+aiohappyeyeballs==2.4.4
+aiohttp==3.11.11
+aiosignal==1.3.2
+altair==5.5.0
+annotated-types==0.7.0
+anyio==4.7.0
+attrs==24.3.0
+blinker==1.9.0
+cachetools==5.5.0
+certifi==2024.12.14
+cffi==1.17.1
+charset-normalizer==3.4.1
+click==8.1.8
+cryptography==44.0.0
+distro==1.9.0
+frozenlist==1.5.0
+gitdb==4.0.12
+GitPython==3.1.44
+google-ai-generativelanguage==0.6.10
+google-api-core==2.24.0
+google-api-python-client==2.157.0
+google-auth==2.37.0
+google-auth-httplib2==0.2.0
+google-generativeai==0.8.3
+googleapis-common-protos==1.66.0
+grpcio==1.68.1
+grpcio-status==1.68.1
+h11==0.14.0
+httpcore==1.0.7
+httplib2==0.22.0
+httpx==0.28.1
+idna==3.10
+iniconfig==2.0.0
+Jinja2==3.1.5
+jiter==0.8.2
+joblib==1.4.2
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+logging==0.4.9.6
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+multidict==6.1.0
+narwhals==1.20.1
+nltk==3.9.1
+numpy==2.2.1
+openai==1.58.1
+packaging==24.2
+pandas==2.2.3
+pdfminer.six==20240706
+pillow==11.1.0
+pluggy==1.5.0
+propcache==0.2.1
+proto-plus==1.25.0
+protobuf==5.29.2
+pyarrow==18.1.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.1
+pycparser==2.22
+pydantic==2.10.4
+pydantic_core==2.27.2
+pydeck==0.9.1
+Pygments==2.18.0
+pyparsing==3.2.1
+pytest==8.3.4
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+pytz==2024.2
+referencing==0.35.1
+regex==2024.11.6
+requests==2.32.3
+rich==13.9.4
+rpds-py==0.22.3
+rsa==4.9
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+streamlit==1.41.1
+streamlit-option-menu==0.4.0
+tenacity==9.0.0
+textblob==0.18.0.post0
+toml==0.10.2
+tornado==6.4.2
+tqdm==4.67.1
+typing_extensions==4.12.2
+tzdata==2024.2
+uritemplate==4.1.1
+urllib3==2.3.0
+watchdog==6.0.0
+yarl==1.18.3

src/evaluate.py

@@ -0,0 +1,53 @@
+import google.generativeai as genai
+from prompts.prompts import PromptGenerator
+from dotenv import load_dotenv
+load_dotenv
+import os
+api_key = os.getenv("GOOGLE_API_KEY")
+class AnswerEvaluator:
+    def __init__(self, api_key):
+        """Initialize with the Gemini API key."""
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel("gemini-pro")
+
+    def evaluate_answers(self, all_answers):
+        """Evaluates answers based on their relevance, accuracy, and clarity."""
+        prompt = self._construct_prompt(all_answers)
+
+        try:
+            # Evaluate the answers using Gemini's model
+            response = self.model.generate_content(
+                prompt
+            )
+
+            # Return the response generated by the model
+            return response.text.strip()
+
+        except Exception as e:
+            return f"Error in evaluation: {str(e)}"
+
+    def _construct_prompt(self, all_answers):
+        """Constructs a detailed prompt for the Gemini model."""
+        prompt = PromptGenerator()
+        evaluation_prompt = prompt.evaluate_prompt()
+
+        for idx, item in enumerate(all_answers, 1):
+            evaluation_prompt += f"\n{idx}. Question: {item['question']}\n   Answer: {item['answer']}\n"
+
+        evaluation_prompt += "\nProvide your detailed evaluation below:"
+        return evaluation_prompt
+
+
+# Initialize with your Gemini API key
+api_key = os.getenv("GOOGLE_API_KEY")
+evaluator = AnswerEvaluator(api_key)
+
+# Example answers
+all_answers = [
+    {"question": "What is machine learning?", "answer": "Machine learning is a subset of AI."},
+    {"question": "Explain logistic regression.", "answer": "It is used to classify data points into classes."},
+]
+
+# Evaluate the answers
+evaluation_result = evaluator.evaluate_answers(all_answers)
+print(evaluation_result)

src/feedback.py

@@ -0,0 +1,46 @@
+import streamlit as st
+
+from textblob import TextBlob  # Install using: pip install textblob
+def feed_back():
+    # Collect user feedback
+    st.write("---")
+    st.write("### Chatbot Feedback")
+    feedback = st.text_area("Additional Feedback:")
+    
+    if st.button("Submit Feedback"):
+        # Show thank you message after submitting feedback
+        st.success("Thank you for your feedback!")
+        
+        # Perform sentiment analysis on the provided feedback
+        predict_sentiment(feedback)
+
+
+        # Optionally, save or store feedback data
+        # feedback_data = {
+        #     "rating": rating,
+        #     "feedback": feedback,
+        # }
+        # st.write("Feedback Data:", feedback_data)
+
+    return feedback
+
+def predict_sentiment(feedback):
+    if feedback:  # Only perform sentiment analysis if feedback is provided
+        # Analyze sentiment
+        analysis = TextBlob(feedback)
+        sentiment_score = analysis.sentiment.polarity
+        
+        # Predict sentiment
+        if sentiment_score > 0:
+            sentiment = "Positive 😊"
+        elif sentiment_score < 0:
+            sentiment = "Negative 😞"
+        else:
+            sentiment = "Neutral 😐"
+        
+        # Display sentiment analysis result
+        st.write(f"Sentiment Analysis Result: **{sentiment}**")
+        # st.write(f"Sentiment Score: {sentiment_score}")
+
+# Running the feedback function
+# feed_back()

src/greetings.py

@@ -0,0 +1,37 @@
+import streamlit as st
+
+import streamlit as st
+
+def start_greeting():
+    # Display a friendly greeting message to the candidate
+    st.write("---")
+    st.write("### Welcome to the TalentScout Hiring Assistant Chatbot! 🎉")
+    
+    # Greet the candidate and introduce the purpose of the chatbot
+    st.write("Hello and thank you for applying! I'm here to help you through the interview process.")
+    st.write("We'll be reviewing your skills and experience through a series of technical questions. Let's get started!")
+
+    # Optionally, you can provide a brief overview of the process
+    st.write("You'll have the opportunity to upload your resume or enter your details manually. Then, I'll generate some technical questions based on your expertise.")
+    
+    # Encourage the candidate to proceed
+    st.write("Please select your preferred method to proceed, and we'll take it from there!")
+
+# Call this function to display the greeting message at the beginning
+# start_greeting()
+
+
+def end_conversation():
+    # After submitting answers, display a thank you message
+    st.write("---")
+    end_greetings = """
+                ### Thank You for Your Responses!
+                Thank you for your time and thoughtful answers. We appreciate your interest in the position!\n
+                Our team will review your responses and contact you soon regarding the next steps in the hiring process.\n
+                If you have any questions or need further assistance, feel free to reach out!\n
+                Good luck and stay positive! 😊
+                """
+    return end_greetings
+
+def home_greetings():
+    st.write("Home page")

src/home_page.py

@@ -0,0 +1,45 @@
+import streamlit as st 
+
+def home_ui():
+    st.title("TalentScout - Hiring Assistant Chatbot 🤖")
+    st.write("""
+    Welcome to **TalentScout**, your AI-powered hiring assistant! 🎉
+    This tool simplifies the hiring process by leveraging the power of AI to:
+    - Parse resumes and extract candidate details.
+    - Generate tailored technical questions based on a candidate's expertise.
+    - Collect and save answers for structured analysis.
+    
+    Navigate using the sidebar to:
+    - Upload a candidate's resume for automated parsing.
+    - Enter candidate details manually for question generation.
+    
+    Let's revolutionize the hiring process together! 🚀
+    """)
+    st.image(
+        "https://via.placeholder.com/800x400.png?text=Welcome+to+TalentScout",
+        use_container_width=True,
+    )
+
+
+
+def about_me():
+    st.title("About Me 🙋‍♂️ ")
+    st.write("""
+Hello! 👋 I'm **R. Sarath Kumar**, and I'm thrilled to have you here! I’m a dedicated and passionate professional in **Data Science** and **Machine Learning** 🤖.  
+With a strong foundation in statistics, machine learning, and MLOps, I love transforming data into valuable insights and building predictive models that solve real-world problems. My work spans across multiple domains, and I’m always excited to explore new tools and techniques to make data-driven decisions more effective and impactful.
+
+Feel free to browse through my projects, where you’ll find some of the most exciting applications of AI and machine learning, and don't hesitate to reach out if you’d like to connect or discuss potential collaborations!
+""")
+
+
+
+    st.subheader("Contact Information")
+    
+    
+    st.write("🔗LinkedIn: [LinkedIn](https://www.linkedin.com/in/r-sarath-kumar-666084257)") 
+    st.write("🔗Github:[Github](https://www.github.com/sarathkumar1304)") 
+
+    
+    st.write("📧 Email: [[email protected]](mailto:[email protected])")  
+    
+    st.write("📞 Phone: 7780651312")  

src/manual_entry.py

@@ -0,0 +1,88 @@
+# import streamlit as st
+
+
+# class DataProcessor:
+#     def manual_entry_form(self):
+#         with st.form("manual_entry_form"):
+#             name = st.text_input("Full Name")
+#             email = st.text_input("Email Address")
+#             phone = st.text_input("Phone Number")
+#             experience = st.number_input("Years of Experience", min_value=0, step=1)
+#             position = st.text_input("Desired Position")
+#             location = st.text_input("Current Location")
+#             tech_stack = st.text_area("Tech Stack (comma-separated)").split(",")
+#             submit = st.form_submit_button("Submit")
+#             if submit:
+#                 self.display_submitted_data(
+#                 name, email, phone, experience, position, location, tech_stack
+#             )
+#         return tech_stack
+
+
+#     @staticmethod
+#     def display_submitted_data(name, email, phone, experience, position, location, tech_stack):
+#         """Displays the submitted form data."""
+#         st.markdown("### Submitted Information")
+#         st.write(f"**Full Name:** {name}")
+#         st.write(f"**Email Address:** {email}")
+#         st.write(f"**Phone Number:** {phone}")
+#         st.write(f"**Years of Experience:** {experience}")
+#         st.write(f"**Desired Position:** {position}")
+#         st.write(f"**Current Location:** {location}")
+#         st.write(f"**Tech Stack:** {', '.join(tech_stack)}")
+
+            
+    
+        
+
+import streamlit as st
+
+class ManualEntry:
+    def manual_entry_form(self):
+        with st.form("manual_entry_form"):
+            name = st.text_input("Full Name")
+            email = st.text_input("Email Address")
+            phone = st.text_input("Phone Number")
+            experience = st.number_input("Years of Experience", min_value=0, step=1)
+            position = st.text_input("Desired Position")
+            location = st.text_input("Current Location")
+            tech_stack = st.text_area("Tech Stack (comma-separated)").split(",")
+            submit = st.form_submit_button("Submit")
+            
+            # Check if any field is empty
+            if submit:
+                missing_fields = []
+                
+                # Check for empty fields
+                if not name:
+                    missing_fields.append("Full Name")
+                if not email:
+                    missing_fields.append("Email Address")
+                if not phone:
+                    missing_fields.append("Phone Number")
+                if experience == 0:
+                    missing_fields.append("Years of Experience")
+                if not position:
+                    missing_fields.append("Desired Position")
+                if not location:
+                    missing_fields.append("Current Location")
+                if not tech_stack or all(not tech.strip() for tech in tech_stack):
+                    missing_fields.append("Tech Stack")
+                
+                if missing_fields:
+                    # Show a message if any fields are missing
+                    st.warning(f"Please provide details for the following fields: {', '.join(missing_fields)}")
+                else:
+                    self.display_submitted_data(name, email, phone, experience, position, location, tech_stack)
+                    return tech_stack
+        
+
+    def display_submitted_data(self, name, email, phone, experience, position, location, tech_stack):
+        st.success("Data Submitted Successfully!")
+        st.write(f"**Name:** {name}")
+        st.write(f"**Email:** {email}")
+        st.write(f"**Phone:** {phone}")
+        st.write(f"**Experience:** {experience} years")
+        st.write(f"**Position:** {position}")
+        st.write(f"**Location:** {location}")
+        st.write(f"**Tech Stack:** {', '.join(tech_stack)}")

src/resume_parser.py

@@ -0,0 +1,115 @@
+from pdfminer.high_level import extract_text
+import re
+from datetime import datetime
+
+class ResumeParser:
+    def parse(self, resume_file):
+        """Extracts text from a PDF resume and processes candidate information."""
+        text = extract_text(resume_file)
+        return self.extract_candidate_info(text)
+
+    def extract_candidate_info(self, text):
+        """Extracts candidate details from the parsed resume text."""
+        return {
+            "name": self.extract_name(text),
+            "email": self.extract_email(text),
+            "phone": self.extract_phone(text),
+            "experience": self.extract_experience(text),
+            "position": self.extract_position(text),
+            "location": self.extract_location(text),
+            "tech_stack": self.extract_tech_stack(text),
+        }
+
+    @staticmethod
+    def extract_name(text):
+        """Extracts the candidate's name from the first line or common patterns."""
+        # Split text into lines and take the first non-empty line
+        lines = text.splitlines()
+        for line in lines:
+            line = line.strip()
+            if line:  # Ignore empty lines
+                # Check for a valid name format (e.g., avoiding single words like "Resume")
+                if len(line.split()) >= 2:  # Name should have at least two words
+                    return line
+                break
+        return "Name not found"
+
+    @staticmethod
+    def extract_email(text):
+        """Extracts the candidate's email address."""
+        match = re.search(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", text)
+        return match.group(0) if match else "Email not found"
+
+    @staticmethod
+    def extract_phone(text):
+        """Extracts the candidate's phone number."""
+        match = re.search(r"\+?\d{10,13}", text)
+        return match.group(0) if match else "Phone number not found"
+
+    @staticmethod
+    def extract_position(text):
+        """Extracts the candidate's position (e.g., Job Title)."""
+        match = re.search(r"(?i)experience(?:\:|\s+)([^\n]+)", text)
+        return match.group(1).strip() if match else "Position not found"
+
+    @staticmethod
+    def extract_location(text):
+        """Extracts the candidate's location."""
+        # Regex to match patterns like 'Location: Bengaluru, Karnataka' or standalone 'Bengaluru, Karnataka'
+        match = re.search(r"(?i)location(?:\:|\s+)([^\n]+)|\b([A-Za-z\s]+,\s*[A-Za-z\s]+)\b", text)
+        if match:
+            # Group 1 matches 'Location: <value>' and Group 2 matches '<City>, <State>'
+            location = match.group(1) or match.group(2)
+            return location.strip()
+        return "Location not found"
+
+    @staticmethod
+    def extract_tech_stack(text):
+        """Extracts technical skills dynamically from the skills section."""
+        # Find the 'Skills' or 'Technical Skills' section in the text
+        match = re.search(r"(?i)(skills|technical skills)(?:\:|\s+)([^\n]+)", text)
+        if match:
+            tech_line = match.group(2).strip()
+            # Split the skills based on common delimiters (comma, semicolon, etc.)
+            skills = re.split(r"[,\;\|]", tech_line)
+            # Strip whitespace and return unique skills
+            return [skill.strip() for skill in skills if skill.strip()]
+        return ["No tech stack found"]
+    @staticmethod
+    def extract_experience(text):
+        """Extracts and calculates the candidate's total experience based on date ranges."""
+        # Updated regex pattern to match abbreviated and full month names along with 'Present'
+        date_pattern = 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)?) \d{4})"
+        regex = rf"{date_pattern}\s*-\s*({date_pattern}|Present)"
+
+        matches = re.findall(regex, text, re.IGNORECASE)
+
+        total_months = 0
+        for match in matches:
+            start_date_str = match[0]
+            end_date_str = match[1]
+
+            start_date = ResumeParser.parse_date(start_date_str)
+            end_date = datetime.now() if "Present" in end_date_str else ResumeParser.parse_date(end_date_str)
+
+            if start_date and end_date:
+                delta = (end_date.year - start_date.year) * 12 + (end_date.month - start_date.month)
+                total_months += delta
+
+        years = total_months // 12
+        months = total_months % 12
+
+        return f"{years} years, {months} months" if total_months > 0 else "Experience not found"
+
+    @staticmethod
+    def parse_date(date_str):
+        """Parses a date string like 'January 2015' or 'Feb 2024' into a datetime object."""
+        try:
+            return datetime.strptime(date_str, "%b %Y")  # Abbreviated month
+        except ValueError:
+            try:
+                return datetime.strptime(date_str, "%B %Y")  # Full month
+            except ValueError:
+                return None
+
+