Upload 12 files

login_module/account.py

@@ -0,0 +1,33 @@
+import streamlit as st
+from firebase_admin import firestore
+
+def account_app():
+    # st.title('User :violet[Account]')
+    # check if login
+    if 'username' not in st.session_state:
+        st.session_state.username = ''
+    if 'useremail' not in st.session_state:
+        st.session_state.useremail = ''
+
+    # if not login then go to login page
+    if st.session_state.username == '':
+        st.title('Welcome to your :violet[Account]')
+        st.write('This is your account page.')
+        st.write('Here you can see your account details and change your password.')
+        st.subheader('Please login to continue')
+        st.subheader('You can login from the sidebar')
+        return
+
+    else:
+        st.title('Welcome ' + st.session_state["username"] + ' to your :violet[Account]')
+        st.write('You are logged in as: ' + st.session_state['username'])
+        st.write('Your email is: ' + st.session_state['useremail'])
+        st.write('You can also logout from here.')
+        if st.button('Logout'):
+            st.session_state.username = ''
+            st.session_state.useremail = ''
+            st.session_state.signedout = True
+            st.session_state.signout = True
+            st.success('You have been logged out')
+            st.write('You can login from the sidebar')
+        return

login_module/chat.py

@@ -0,0 +1,187 @@
+# PrepGenie/login_module/chat.py
+import gradio as gr
+import tempfile
+import os
+import PyPDF2
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configure Generative AI
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY") or "YOUR_DEFAULT_API_KEY_HERE")
+text_model = genai.GenerativeModel("gemini-pro")
+
+# --- Helper Functions (Logic from Streamlit Chat) ---
+
+def file_processing_chat(pdf_file_path):
+    """Processes the uploaded PDF file."""
+    if not pdf_file_path:
+        return ""
+    try:
+        with open(pdf_file_path, "rb") as f:
+            reader = PyPDF2.PdfReader(f)
+            text = ""
+            for page in reader.pages:
+                text += page.extract_text()
+        return text
+    except Exception as e:
+        print(f"Error processing PDF: {e}")
+        return ""
+
+def getallinfo_chat(data):
+    """Formats resume data."""
+    if not data or not data.strip():
+        return "No resume data provided or data is empty."
+
+    text = f"""{data} is given by the user. Make sure you are getting the details like name, experience,
+            education, skills of the user like in a resume. If the details are not provided return: not a resume.
+            If details are provided then please try again and format the whole in a single paragraph covering all the information. """
+    try:
+        response = text_model.generate_content(text)
+        response.resolve()
+        return response.text
+    except Exception as e:
+        print(f"Error formatting resume data: {e}")
+        return "Error processing resume data."
+
+def get_answer(question, input_text):
+    """Generates answer/suggestions based on the question and resume text."""
+    # Handle empty inputs
+    if not question or not question.strip() or not input_text or not input_text.strip():
+        return "Please provide a question and ensure your resume is processed."
+
+    text = f"""You are a Great Resume Checker, you are given the details about the user and the user
+            needs some changes about their resume and you are the one to guide them.
+            There are queries which user wants to be solved about their resume. You are asked a question which is: {question} and
+            you have to generate suggestions to improve the resume based on the text: {input_text}. Answer in a way that the user
+            can understand and make the changes in their resume. and In paragraph form. maximum of 2 paragraphs. dont tell over the top.
+            it should be less and precise. dont tell the user to change the whole resume. just give them some suggestions. dont give
+            bullet points. Be point to point with user."""
+    try:
+        response = text_model.generate_content(text)
+        response.resolve()
+        return response.text
+    except Exception as e:
+        print(f"Error generating answer: {e}")
+        return "Sorry, I couldn't generate an answer at the moment."
+
+# --- Gradio Chat Interface Functions ---
+
+def process_resume_chat(file_obj):
+    """Handles resume upload and initial processing for chat."""
+    if not file_obj:
+        return "Please upload a PDF resume.", "", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+
+    try:
+        # Save uploaded file to a temporary location
+        temp_dir = tempfile.mkdtemp()
+        file_path = os.path.join(temp_dir, file_obj.name)
+        with open(file_path, "wb") as f:
+            f.write(file_obj.read())
+
+        # Process the PDF
+        raw_text = file_processing_chat(file_path)
+        if not raw_text.strip():
+             os.remove(file_path)
+             os.rmdir(temp_dir)
+             return "Could not extract text from the PDF.", "", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+
+        processed_data = getallinfo_chat(raw_text)
+
+        # Clean up temporary file
+        os.remove(file_path)
+        os.rmdir(temp_dir)
+
+        return (
+            f"Resume processed successfully!",
+            processed_data, # Pass processed data for chat
+            gr.update(visible=True), # Show chat input
+            gr.update(visible=True), # Show send button
+            [] # Clear previous chat history (return empty list for Chatbot)
+        )
+    except Exception as e:
+        error_msg = f"Error processing file: {str(e)}"
+        print(error_msg)
+        return error_msg, "", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
+
+def chat_with_resume(query, resume_data, history):
+    """Handles the chat interaction."""
+    # history is automatically managed by Gradio Chatbot, we just need to append to it
+    if not query or not query.strip() or not resume_data or not resume_data.strip():
+        # Return existing history if inputs are missing or empty
+        # Gradio Chatbot expects a list of tuples [(user_msg, bot_response), ...]
+        # If history is None, initialize as empty list
+        current_history = history if history is not None else []
+        # Add the error message to the chat history
+        current_history.append((query if query else "", "Please enter a question and ensure your resume is processed."))
+        return "", current_history # Clear input, update history
+
+    try:
+        answer = get_answer(query, resume_data)
+        # Update history
+        # Gradio Chatbot expects a list of tuples [(user_msg, bot_response), ...]
+        current_history = history if history is not None else []
+        current_history.append((query, answer))
+        return "", current_history # Clear input, update history
+    except Exception as e:
+        error_msg = f"Error during chat: {str(e)}"
+        print(error_msg)
+        current_history = history if history is not None else []
+        current_history.append((query, error_msg))
+        return "", current_history
+
+# --- Gradio Chat Interface ---
+# This can be integrated into the main app.py or run as a separate demo
+# For integration, you would typically define these components inside a Gradio Column/Row
+# within app.py and connect their event listeners there.
+
+# Example of how this might look as a standalone demo (commented out for integration):
+#
+# with gr.Blocks(title="PrepGenie - Chat with Resume") as chat_demo:
+#     gr.Markdown("# 🦈 PrepGenie - Chat with Resume")
+#     gr.Markdown("Upload your resume and ask questions about it.")
+#
+#     # State for processed resume data
+#     processed_resume_data_chat = gr.State("")
+#
+#     with gr.Row():
+#         with gr.Column():
+#             file_upload_chat = gr.File(label="Upload Resume (PDF)", file_types=[".pdf"])
+#             process_chat_btn = gr.Button("Process Resume")
+#         with gr.Column():
+#             file_status_chat = gr.Textbox(label="Status", interactive=False)
+#
+#     # Chat Section (Initially hidden)
+#     chatbot = gr.Chatbot(label="Chat History", visible=False)
+#     query_input = gr.Textbox(label="Ask about your resume", placeholder="Type your question here...", visible=False)
+#     send_btn = gr.Button("Send", visible=False)
+#
+#     # --- Event Listeners for Chat ---
+#
+#     # Process Resume for Chat
+#     process_chat_btn.click(
+#         fn=process_resume_chat,
+#         inputs=[file_upload_chat],
+#         outputs=[file_status_chat, processed_resume_data_chat, query_input, send_btn, chatbot]
+#     )
+#
+#     # Chat Interaction
+#     send_btn.click(
+#         fn=chat_with_resume,
+#         inputs=[query_input, processed_resume_data_chat, chatbot], # chatbot provides history
+#         outputs=[query_input, chatbot] # Update input (clear) and chatbot (new history)
+#     )
+#     query_input.submit( # Allow submitting with Enter key
+#         fn=chat_with_resume,
+#         inputs=[query_input, processed_resume_data_chat, chatbot],
+#         outputs=[query_input, chatbot]
+#     )
+#
+# # Run the chat app separately or integrate into main app
+# # if __name__ == "__main__":
+# #     chat_demo.launch()
+
+# Print statement to confirm module load (optional)
+print("Chat module loaded successfully.")

login_module/evaluate.py

@@ -0,0 +1,130 @@
+
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+import io
+import base64
+
+
+
+def create_metrics_chart(metrics_dict):
+    """Creates a pie chart image from metrics."""
+    try:
+        labels = list(metrics_dict.keys())
+        sizes = list(metrics_dict.values())
+
+        fig, ax = plt.subplots(figsize=(6, 6)) # Adjust size as needed
+        ax.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=90)
+        ax.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.
+
+        # Save plot to a BytesIO object
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close(fig) # Important to close the figure
+        return buf
+    except Exception as e:
+        print(f"Error creating chart: {e}")
+        return None
+
+def generate_evaluation_report(metrics_data_list):
+    """
+    Generates a text evaluation report and a chart.
+    metrics_data_list: List of dictionaries, each containing metrics for a question.
+    """
+    if not metrics_data_list:
+        return "No interview data available for evaluation.", None
+
+    # Aggregate metrics (average scores)
+    aggregated_metrics = {
+        "Communication skills": 0.0,
+        "Teamwork and collaboration": 0.0,
+        "Problem-solving and critical thinking": 0.0,
+        "Time management and organization": 0.0,
+        "Adaptability and resilience": 0.0
+    }
+    num_questions = len(metrics_data_list)
+    if num_questions == 0:
+        num_questions = 1 # Avoid division by zero
+
+    for metrics_dict in metrics_data_list:
+        for key, value in metrics_dict.items():
+            if key in aggregated_metrics:
+                aggregated_metrics[key] += value
+
+    for key in aggregated_metrics:
+        aggregated_metrics[key] /= num_questions
+        aggregated_metrics[key] = round(aggregated_metrics[key], 2) # Round to 2 decimal places
+
+    average_rating = sum(aggregated_metrics.values()) / len(aggregated_metrics)
+    average_rating = round(average_rating, 2)
+
+    # --- Generate Text Report ---
+    report_lines = [f"## Hey Candidate, here is your interview evaluation:\n"]
+    report_lines.append("### Skill Ratings:\n")
+    for metric, rating in aggregated_metrics.items():
+        report_lines.append(f"* **{metric}:** {rating}/10\n")
+
+    report_lines.append(f"\n### Overall Average Rating: {average_rating:.2f}/10\n")
+
+    improvement_content = """
+### Areas for Improvement:
+
+*   **Communication:** Focus on clarity, conciseness, and tailoring your responses to the audience. Use examples and evidence to support your points.
+*   **Teamwork and collaboration:** Highlight your teamwork skills through specific examples and demonstrate your ability to work effectively with others.
+*   **Problem-solving and critical thinking:** Clearly explain your problem-solving approach and thought process. Show your ability to analyze information and arrive at logical solutions.
+*   **Time management and organization:** Emphasize your ability to manage time effectively and stay organized during challenging situations.
+*   **Adaptability and resilience:** Demonstrate your ability to adapt to new situations and overcome challenges. Share examples of how you have handled unexpected situations or setbacks in the past.
+
+**Remember:** This is just a starting point. Customize the feedback based on the specific strengths and weaknesses identified in your interview.
+"""
+    report_lines.append(improvement_content)
+    report_text = "".join(report_lines)
+
+    # --- Generate Chart ---
+    chart_buffer = create_metrics_chart(aggregated_metrics)
+
+    return report_text, chart_buffer
+
+# --- Gradio Interface for Evaluation (Example Usage) ---
+
+# This part would typically be called from your main interview completion logic
+# and the outputs connected to Gradio components.
+
+# Example dummy data for testing the evaluation function
+# dummy_metrics_data = [
+#     {
+#         "Communication skills": 7.5,
+#         "Teamwork and collaboration": 6.0,
+#         "Problem-solving and critical thinking": 8.0,
+#         "Time management and organization": 5.5,
+#         "Adaptability and resilience": 7.0
+#     },
+#     {
+#         "Communication skills": 8.0,
+#         "Teamwork and collaboration": 7.5,
+#         "Problem-solving and critical thinking": 6.5,
+#         "Time management and organization": 8.0,
+#         "Adaptability and resilience": 6.0
+#     }
+# ]
+
+# def run_evaluation(metrics_data_input):
+#     report, chart = generate_evaluation_report(metrics_data_input)
+#     return report, chart
+
+# with gr.Blocks() as eval_demo:
+#     gr.Markdown("## Interview Evaluation")
+#     metrics_input = gr.JSON(label="Metrics Data (List of Dicts)", value=dummy_metrics_data)
+#     run_btn = gr.Button("Generate Evaluation")
+#     report_output = gr.Markdown(label="Evaluation Report")
+#     chart_output = gr.Image(label="Skills Breakdown", type="pil") # or type="filepath"
+
+#     run_btn.click(
+#         fn=run_evaluation,
+#         inputs=metrics_input,
+#         outputs=[report_output, chart_output]
+#     )
+
+# if __name__ == "__main__":
+#     eval_demo.launch()

login_module/test.py

@@ -0,0 +1,70 @@
+# import streamlit as st
+# from firebase_admin import auth
+
+
+# # cred = credentials.Certificate("pondering-5ff7c-c033cfade319.json")
+# # firebase_admin.initialize_app(cred)
+# def test_app():
+# # Usernm = []
+#     st.title('Welcome to our :violet[Mock Interview]')
+
+#     if 'username' not in st.session_state:
+#         st.session_state.username = ''
+#     if 'useremail' not in st.session_state:
+#         st.session_state.useremail = ''
+
+
+#     def f(): 
+#         try:
+#             user = auth.get_user_by_email(email)
+#             # print(user.uid)
+#             print('Login Successful')
+#             st.session_state.username = user.uid
+#             st.session_state.useremail = user.email
+            
+#             global Usernm
+#             Usernm=(user.uid)
+            
+#             st.session_state.signedout = True
+#             st.session_state.signout = True    
+  
+#         except: 
+#             st.warning('Login Failed')
+
+#     def t():
+#         st.session_state.signout = False
+#         st.session_state.signedout = False   
+#         st.session_state.username = ''
+
+        
+#     if "signedout"  not in st.session_state:
+#         st.session_state["signedout"] = False
+#     if 'signout' not in st.session_state:
+#         st.session_state['signout'] = False    
+        
+
+#     if  not st.session_state["signedout"]: # only show if the state is False, hence the button has never been clicked
+#         choice = st.selectbox('Login/Signup',['Login','Sign up'])
+#         email = st.text_input('Email Address')
+#         password = st.text_input('Password',type='password')
+        
+
+        
+#         if choice == 'Sign up':
+#             username = st.text_input("Enter  your unique username")
+            
+#             if st.button('Create my account'):
+#                 user = auth.create_user(email = email, password = password,uid=username)
+                
+#                 st.success('Account created successfully!')
+#                 st.markdown('Please Login using your email and password')
+#                 st.balloons()
+#         else:
+#             # st.button('Login', on_click=f)          
+#             st.button('Login', on_click=f)
+            
+            
+#     if st.session_state.signout:
+#         st.text('Name '+st.session_state.username)
+#         st.text('Email id: '+st.session_state.useremail)
+#         st.button('Sign out', on_click=t) 

login_module/your.py

@@ -0,0 +1,27 @@
+# import streamlit as st
+# from firebase_admin import firestore
+
+  
+# def app():
+#     db=firestore.client()
+#     try:
+#         st.title('Posted by: '+st.session_state['username'] )
+#         result = db.collection('Posts').document(st.session_state['username']).get()
+#         r=result.to_dict()
+#         content = r['Content']
+#         def delete_post(k):
+#             c=int(k)
+#             h=content[c]
+#             try:
+#                 db.collection('Posts').document(st.session_state['username']).update({"Content": firestore.ArrayRemove([h])})
+#                 st.warning('Post deleted')
+#             except:
+#                 st.write('Something went wrong..')
+#         for c in range(len(content)-1,-1,-1):
+#             st.text_area(label='',value=content[c])
+#             st.button('Delete Post', on_click=delete_post, args=([c] ), key=c)        
+
+        
+#     except:
+#         if st.session_state.username=='':
+#             st.text('Please Login first')