Update app.py (#1)

- Update app.py (ba6ad99ac665254c6bffe15f14632424452dc103)

app.py

@@ -1,362 +1,163 @@
-import PyPDF2
 import streamlit as st
-from transformers import pipeline
-import io
-from datetime import datetime, timedelta
-import gspread
-from google.oauth2.service_account import Credentials
-import pandas as pd
-import matplotlib.pyplot as plt
-from io import BytesIO
-from reportlab.lib.pagesizes import letter
-from reportlab.pdfgen import canvas
-import speech_recognition as sr  # Speech recognition package
-import plotly.express as px  # For interactive charts
-
-# Google Sheets setup
-SCOPE = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
-CREDS_PATH = "modern-cycling-444916-g6-82c207d3eb47.json"  # Provide your Google credentials path
-
-# Initialize the Hugging Face QA pipeline
-qa_pipeline = pipeline("question-answering")
+import requests
+import os
+from hashlib import sha256
+import random
+
+# ========== CONFIG ==========
+GROQ_API_KEY = "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"  # Replace with your actual key
+GROQ_MODEL = "llama3-8b-8192"       # Recommended current Groq model
+
+# ========== STATE ==========
+if "last_result" not in st.session_state:
+    st.session_state.last_result = None
+if "last_candidate" not in st.session_state:
+    st.session_state.last_candidate = None
+
+# ========== GROQ HELPERS ==========
+
+def generate_questions(domain: str, round_type: str):
+    prompt = f"""
+    Generate 3 {round_type} interview questions for a candidate in the domain of {domain}.
+    Questions should be clear, concise, and assess relevant skills.
+    """
+    headers = {"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"}
+    data = {
+        "model": GROQ_MODEL,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.7,
+        "max_tokens": 400,
+    }
 
-# Initialize Sentiment Analysis Pipeline using Hugging Face
-sentiment_model = pipeline('sentiment-analysis')
+    response = requests.post("https://api.groq.com/openai/v1/chat/completions", headers=headers, json=data)
 
-# Initialize Google Sheets connection
-def initialize_google_sheets():
-    credentials = Credentials.from_service_account_file(CREDS_PATH, scopes=SCOPE)
     try:
-        client = gspread.authorize(credentials)
-        sheet = client.open("SalesStores").sheet1  # Change Google Sheet name to "SalesStores"
-        return sheet
-    except gspread.exceptions.APIError as e:
-        st.error(f"Google Sheets API error: {e}")
-        return None
-
-sheet = initialize_google_sheets()
-
-# Function to extract text from PDF using PyPDF2
-def extract_pdf_text_with_pypdf(pdf_file):
-    pdf_text = ""
-    with io.BytesIO(pdf_file.read()) as pdf_data:
-        pdf_reader = PyPDF2.PdfReader(pdf_data)
-        for page_num in range(len(pdf_reader.pages)):
-            page = pdf_reader.pages[page_num]
-            pdf_text += page.extract_text()
-    return pdf_text.strip()
-
-# Function to answer a query using Hugging Face's QA pipeline
-def answer_query(question, context):
-    result = qa_pipeline(question=question, context=context)
-    return result['answer']
-
-# Function to analyze sentiment using Hugging Face's pre-trained model
-def analyze_sentiment(text):
-    sentiment = sentiment_model(text)[0]  # Output is a list of dictionaries
-    label = sentiment['label']
-    score = sentiment['score']
-    
-    # Define sentiment labels
-    if label == "POSITIVE" and score > 0.6:
-        sentiment_description = "Positive"
-    elif label == "NEGATIVE" and score < 0.4:  # Adjust threshold for negative sentiment
-        sentiment_description = "Negative"
-    else:
-        sentiment_description = "Neutral"
-    
-    return score, sentiment_description
-
-# Function to update Google Sheets without product name
-def update_sheet_without_product(sentiment_score, sentiment_description, relevant_answer):
-    if sheet:
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        sheet.append_row([timestamp, sentiment_description, sentiment_score, relevant_answer, "No Product Name"])
-    else:
-        st.error("Google Sheets connection not initialized.")
+        res_json = response.json()
+        return [q.strip("- ").strip() for q in res_json['choices'][0]['message']['content'].split("\n") if q.strip()]
+    except Exception as e:
+        st.error(f"Groq API Error: {e}")
+        st.json(response.json())
+        return ["Question 1", "Question 2", "Question 3"]
+
+def generate_programming_question(domain: str, language: str):
+    prompt = f"""
+    Generate 1 beginner-to-intermediate level programming interview question in {language} for a candidate applying in the domain of {domain}.
+    Provide only the question without solution or explanation.
+    """
+    headers = {"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"}
+    data = {
+        "model": GROQ_MODEL,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.7,
+        "max_tokens": 300,
+    }
 
-# Function to suggest product recommendations based on sentiment or query
-def suggest_product_recommendations(sentiment_description, query):
-    recommendations = []
+    response = requests.post("https://api.groq.com/openai/v1/chat/completions", headers=headers, json=data)
 
-    # Recognize product types based on the query
-    if "laptop" in query.lower():
-        if sentiment_description == "Positive":
-            recommendations = [
-                "Check out this high-performance gaming laptop!",
-                "How about this ultrabook for portability?",
-                "This laptop has excellent reviews – perfect for professionals!"
-            ]
-        elif sentiment_description == "Negative":
-            recommendations = [
-                "Perhaps you might prefer these affordable laptops instead.",
-                "Looking for a different brand? Check these out!"
-            ]
-        else:
-            recommendations = [
-                "Here are some of the best laptops available right now."
-            ]
-    elif "smartphone" in query.lower():
-        if sentiment_description == "Positive":
-            recommendations = [
-                "This smartphone has fantastic features, check it out!",
-                "Here's a popular smartphone with excellent camera quality."
-            ]
-        elif sentiment_description == "Negative":
-            recommendations = [
-                "Maybe you’d like to consider another smartphone brand?",
-                "These budget smartphones offer better value for money."
-            ]
-        else:
-            recommendations = [
-                "Here’s a list of the latest smartphones that might interest you."
-            ]
-    elif "headphones" in query.lower():
-        if sentiment_description == "Positive":
-            recommendations = [
-                "These wireless headphones offer superior sound quality.",
-                "Looking for noise-cancelling headphones? Try these."
-            ]
-        elif sentiment_description == "Negative":
-            recommendations = [
-                "Consider these alternative headphones with better reviews.",
-                "These highly-rated, affordable options might suit your needs."
-            ]
-        else:
-            recommendations = [
-                "Check out these top-rated headphones for music lovers!"
-            ]
-    elif "tablet" in query.lower():
-        if sentiment_description == "Positive":
-            recommendations = [
-                "Check out this lightweight tablet with amazing battery life.",
-                "This tablet has incredible processing power and an excellent screen."
-            ]
-        elif sentiment_description == "Negative":
-            recommendations = [
-                "Here’s an alternative tablet with a better display.",
-                "These budget tablets might be more up your alley."
-            ]
-        else:
-            recommendations = [
-                "Looking for a tablet? Here are some of the best options right now."
-            ]
-    elif "camera" in query.lower():
-        if sentiment_description == "Positive":
-            recommendations = [
-                "This camera offers stunning image quality for professionals.",
-                "Perfect for vloggers! Check out this high-quality camera."
-            ]
-        elif sentiment_description == "Negative":
-            recommendations = [
-                "Maybe you’d prefer these budget-friendly cameras with better features.",
-                "Here are some alternatives for beginner photographers."
-            ]
-        else:
-            recommendations = [
-                "Explore these top-rated cameras for your photography needs!"
-            ]
+    try:
+        return response.json()['choices'][0]['message']['content']
+    except Exception as e:
+        st.error(f"Groq API Error: {e}")
+        st.json(response.json())
+        return "Write a function to reverse a string."
+
+# ========== CORE FUNCTIONALITY ==========
+
+def check_resume_originality(uploaded_file):
+    content = uploaded_file.read()
+    resume_hash = sha256(content).hexdigest()
+    existing_hashes = ["abc123", "def456"]  # Dummy hashes - replace with real hashes database
+    return 20 if resume_hash in existing_hashes else 95
+
+def save_to_crm(name, domain, result):
+    # Placeholder for CRM integration - replace with real CRM API calls
+    print(f"[CRM] Candidate: {name}, Domain: {domain}, Result: {result}")
+
+def show_dashboard():
+    st.title("📊 Dashboard")
+    if st.session_state.last_result:
+        st.subheader("Latest Candidate Summary")
+        total_score = sum(st.session_state.last_result.values()) / len(st.session_state.last_result)
+        st.metric("Overall Score", f"{total_score:.2f}%")
+        st.progress(int(total_score))
+        for k, v in st.session_state.last_result.items():
+            st.write(f"**{k.replace('_', ' ').title()}**: {v:.2f}%")
+        st.info(f"Last candidate: {st.session_state.last_candidate}")
     else:
-        recommendations = [
-            "Based on your query, here are some great product options across various categories."
-        ]
-    
-    return recommendations
-
-# Function to filter data by date
-def filter_data_by_date(data, date_filter):
-    if date_filter == "Today":
-        start_date = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
-        data = data[data['Timestamp'] >= start_date]
-    elif date_filter == "One Week":
-        start_date = datetime.now() - timedelta(weeks=1)
-        data = data[data['Timestamp'] >= start_date]
-    return data
-
-# Function to generate PDF for the call history
-def generate_pdf(data):
-    buffer = BytesIO()
-    c = canvas.Canvas(buffer, pagesize=letter)
-    c.setFont("Helvetica", 10)
-    y_position = 750
-    c.drawString(30, y_position, "Call History Report")
-    y_position -= 20
-    for index, row in data.iterrows():
-        c.drawString(30, y_position, f"Sentiment: {row['Sentiment']}, Answer: {row['Answer']}, Product: {row['Product Name']}")
-        y_position -= 15
-        if y_position <= 40:
-            c.showPage()
-            c.setFont("Helvetica", 10)
-            y_position = 750
-    c.save()
-    buffer.seek(0)
-    return buffer
-
-# Function to listen to speech and convert it to text
-def listen_to_speech():
-    recognizer = sr.Recognizer()
-    with sr.Microphone() as source:
-        recognizer.adjust_for_ambient_noise(source)  # Adjust for background noise
-        st.write("Listening...")  # Optional: Add a message to indicate listening state
-        try:
-            audio = recognizer.listen(source, timeout=5, phrase_time_limit=10)  # Listen for the audio input
-            st.write("Recognizing...")  # Optional: Add a message for recognition process
-            text = recognizer.recognize_google(audio)  # Use Google's speech recognition to convert audio to text
-            st.write(f"Recognized: {text}")
-            return text  # Return the text detected from the audio
-        except sr.UnknownValueError:
-            st.error("Sorry, I could not understand the audio.")  # Handle case when the audio is unclear
-            return None
-        except sr.RequestError:
-            st.error("Could not request results from Google Speech Recognition service.")  # Handle network issues
-            return None
-        except Exception as e:
-            st.error(f"An error occurred: {e}")
-            return None
-
-# Function to suggest related follow-up questions based on the answer
-def suggest_related_questions():
-    related_questions = [
-        "Can you explain more about the product?",
-        "What are the features of this product?",
-        "How does it compare to other products?",
-        "Can I get more details about the specifications?",
-        "What is the price of the product?"
-    ]
-    return related_questions
-
-# Dashboard functions
-def display_dashboard():
-    st.title("Customer Query Dashboard")
-
-    # Adding a background color and styles to enhance the dashboard appearance
-    st.markdown("""
-    <style>
-    .stApp {
-        background-color: #f0f4f8;
+        st.warning("No interview data available yet.")
+
+def start_interview(domain, language):
+    result = {}
+
+    st.subheader("🔢 Round 1: Aptitude")
+    aptitude_qs = generate_questions(domain, "aptitude")
+    aptitude_score = 0
+    for i, q in enumerate(aptitude_qs):
+        ans = st.text_input(f"Aptitude Q{i+1}: {q}", key=f"apt{i}")
+        if ans:
+            aptitude_score += 1
+    result['aptitude_score'] = (aptitude_score / len(aptitude_qs)) * 100
+
+    st.subheader(f"💻 Round 2: Programming in {language}")
+    prog_q = generate_programming_question(domain, language)
+    st.markdown(f"**Problem:** {prog_q}")
+    code_ans = st.text_area(f"Write your solution in {language}", key="code")
+    result['code_score'] = 90 if ("def" in code_ans or "class" in code_ans) and len(code_ans) > 20 else 40
+
+    st.subheader("💬 Round 3: HR Interview")
+    hr_qs = generate_questions(domain, "HR")
+    hr_score = 0
+    for i, q in enumerate(hr_qs):
+        ans = st.text_area(f"HR Q{i+1}: {q}", key=f"hr{i}")
+        hr_score += len(ans.split()) > 15
+    result['hr_score'] = (hr_score / len(hr_qs)) * 100
+
+    st.subheader("🗣️ Round 4: Communication")
+    result['communication_score'] = random.randint(70, 90)
+
+    # --- Show final marks summary ---
+    st.markdown("---")
+    st.header("📋 Interview Summary")
+    rounds = {
+        "Aptitude": result['aptitude_score'],
+        "Programming": result['code_score'],
+        "HR Interview": result['hr_score'],
+        "Communication": result['communication_score'],
     }
-    .stButton>button {
-        background-color: #4CAF50;
-        color: white;
-        border-radius: 10px;
-        padding: 10px 20px;
-    }
-    .stTextInput>div>input {
-        border-radius: 10px;
-        border: 2px solid #4CAF50;
-        padding: 10px;
-    }
-    </style>
-    """, unsafe_allow_html=True)
-
-    # Displaying a greeting message with animation
-    st.balloons()  # Adding confetti animation when the page loads
-
-    if sheet:
-        data = pd.DataFrame(sheet.get_all_records())  # Load all rows into a DataFrame
-
-        # Ensure the Timestamp column exists and is in datetime format
-        if 'Timestamp' in data.columns:
-            data['Timestamp'] = pd.to_datetime(data['Timestamp'])
-
-            # Add a date filter to the dashboard
-            date_filter = st.selectbox("Filter by Date", ["All Time", "Today", "One Week"])
-
-            # Filter data based on the selected date range
-            if date_filter != "All Time":
-                data = filter_data_by_date(data, date_filter)
-
-            # Check if the required columns are present
-            if 'Sentiment' in data.columns and 'Answer' in data.columns:
-                # Filter by product (Amazon or Flipkart)
-                product_filter = st.selectbox("Select Product", ["All", "Amazon", "Flipkart"])
-
-                if product_filter != "All":
-                    data = data[data['Product Name'] == product_filter]
-
-                # Plot sentiment distribution
-                sentiment_counts = data['Sentiment'].value_counts()
-
-                # Plot Sentiment Distribution using Plotly for better interactivity
-                st.subheader("Sentiment Distribution")
-                fig = px.bar(x=sentiment_counts.index, y=sentiment_counts.values, 
-                             labels={'x': 'Sentiment', 'y': 'Frequency'}, 
-                             color=sentiment_counts.index, 
-                             color_discrete_map={"POSITIVE": "green", "NEGATIVE": "red", "NEUTRAL": "gray"})
-                st.plotly_chart(fig)
-
-                # Call Activity Statistics
-                total_calls = len(data)
-                avg_sentiment = data['Sentiment'].apply(lambda x: 1 if x == 'Positive' else -1 if x == 'Negative' else 0).mean()
-                avg_sentiment = round(avg_sentiment, 2)
-
-                st.subheader("Call Activity Statistics")
-                st.write(f"Total Calls: {total_calls}")
-                st.write(f"Average Sentiment: {avg_sentiment}")
-
-                # Download option for the entire history (PDF)
-                pdf = generate_pdf(data)
-                st.download_button(
-                    label="Download Call History as PDF",
-                    data=pdf,
-                    file_name="call_history.pdf",
-                    mime="application/pdf"
-                )
-
-            else:
-                st.error("The required columns (Sentiment, Answer) are not found in the data.")
-                st.write("Check the data structure in the Google Sheet to make sure the columns are correct.")
-
-# Main Streamlit UI and workflow
-def main():
-    st.title('Real-Time Customer Query Analysis & Call History')
-
-    # Sidebar Navigation
-    sidebar_option = st.sidebar.selectbox("Select an Option", ["Dashboard", "Call Analysis"])
 
-    if sidebar_option == "Dashboard":
-        display_dashboard()
+    total = sum(rounds.values()) / len(rounds)
+    for round_name, score in rounds.items():
+        st.write(f"**{round_name}:** {score:.2f}%")
 
-    elif sidebar_option == "Call Analysis":
-        # Upload PDF file
-        uploaded_pdf = st.file_uploader("Upload a PDF file", type="pdf")
-        if uploaded_pdf:
-            pdf_text = extract_pdf_text_with_pypdf(uploaded_pdf)
+    st.write(f"### Overall Score: {total:.2f}%")
+    st.progress(int(total))
 
-            if not pdf_text:
-                st.error("No text could be extracted from the PDF.")
-                return
+    return result
 
-            # Speech recognition button
-            if st.button("Start Speech Recognition"):
-                user_input = listen_to_speech()
-                if user_input:
-                    # Sentiment Analysis
-                    sentiment_score, sentiment_description = analyze_sentiment(user_input)
+# ========== MAIN APP ==========
+st.set_page_config(page_title="AI Interview System", layout="centered")
+page = st.sidebar.radio("📌 Navigate", ["Interview", "Dashboard"])
 
-                    # Answer the query using the Hugging Face QA pipeline
-                    answer = answer_query(user_input, pdf_text)
-                    st.write(f"Answer: {answer}")
+if page == "Interview":
+    st.title("🧠 AI Interview System")
 
-                    # Display Sentiment Result
-                    st.write(f"Sentiment: {sentiment_description} (Score: {sentiment_score:.2f})")
+    uploaded_resume = st.file_uploader("📄 Upload Resume (PDF/DOCX)", type=['pdf', 'docx'])
+    domain = st.selectbox("🎯 Select your domain", ["Software", "Data Science", "Networking", "AI/ML"])
+    language = st.selectbox("💻 Select programming language", ["Python", "Java", "C++", "JavaScript"])
 
-                    # Get product recommendations
-                    recommendations = suggest_product_recommendations(sentiment_description, user_input)
-                    st.subheader("Product Recommendations")
-                    for recommendation in recommendations:
-                        st.write(f"- {recommendation}")
+    if uploaded_resume and domain and language:
+        with st.expander("🔍 Step 1: Resume Originality Check"):
+            score = check_resume_originality(uploaded_resume)
+            st.info(f"Resume Originality Score: **{score}%**")
 
-                    # Store the query and the response in Google Sheets
-                    update_sheet_without_product(sentiment_score, sentiment_description, answer)
+        if st.button("🚀 Start Interview"):
+            result = start_interview(domain, language)
+            st.success("✅ Interview Completed!")
 
-                    st.write("Query and answer saved in Call History!")
+            st.session_state.last_result = result
+            st.session_state.last_candidate = uploaded_resume.name
 
-                    # Suggest related follow-up questions
-                    st.subheader("Related Follow-up Questions")
-                    related_questions = suggest_related_questions()
-                    for question in related_questions:
-                        st.write(f"- {question}")
+            save_to_crm(uploaded_resume.name, domain, result)
 
-if __name__ == "__main__":
-    main()
+elif page == "Dashboard":
+    show_dashboard()