app.py

import time

import pandas as pd
import streamlit as st
import os
import json
from openai import AzureOpenAI
from model import create_models, configure_settings, load_documents_and_create_index, \
    create_chat_prompt_template, execute_query
from datasets import Dataset, DatasetDict, load_dataset, concatenate_datasets

client = AzureOpenAI(azure_endpoint="https://personality-service.openai.azure.com/",
                     api_key=os.getenv("AZURE_OPENAI_KEY"), api_version="2024-02-15-preview")

TOKEN = os.getenv('hf_token')
def store_feedback(user_input, response, feedback, rating,repo):
    dataset = load_dataset(repo, token=TOKEN, download_mode="force_redownload", ignore_verifications=True)
    new_entry = pd.DataFrame({"user_input": [user_input], "response": [response], "feedback": [feedback], "rate": [rating]})
    new_dataset = Dataset.from_pandas(new_entry)
    updated_dataset = concatenate_datasets([dataset["train"], new_dataset])
    updated_dataset.push_to_hub(repo, private=False, token=TOKEN)

# Function to generate a completion using OpenAI API
def generate_one_completion(message, temperature):
    response = client.chat.completions.create(
        model="personality_gpt4o",
        temperature=temperature,
        max_tokens=1000,  # Adjust based on desired response length
        frequency_penalty=0.2,  # To avoid repetition
        presence_penalty=0.2,  # To introduce new topics
        messages=message,
        stream=False
    )

    return response


import json

def get_profile_str(profile):
    bio_info = profile['bio_information']
    main_profile = profile['main_profile']
    red_flag = profile['red_flag']
    motivation = profile['motivation']
    profile_str = f"Bio Information:\n"
    for key, value in bio_info.items():
        profile_str += f"- {key.replace('_', ' ').title()}: {value}\n"
    profile_str += f"\nMain Profile:\n"
    for key, value in main_profile.items():
        profile_str += f"- {key.title()}: {value['score']} - {value['summary']}\n"
    profile_str += f"\nRed Flags:\n"
    for key, value in red_flag.items():
        profile_str += f"- {key.title()}: {value['score']} - {value['summary']}\n"
    profile_str += f"\nMotivation:\n"
    for key, value in motivation.items():
        profile_str += f"- {key.title()}: {value['score']} - {value['summary']}\n"
    return profile_str

def generate_prompt_from_profile(profile, version="TestTakersSummary"):
    with open('prompts.json') as f:
        prompt_sets = json.load(f)['Prompts']
        prompt_templates = prompt_sets[version]

    try:
        # Fetching profile data
        individual_name = profile['bio_information'].get('Name', 'the individual')

        # Generating bio, profile, and red flags sections
        bio_section = "\n".join(
            [f"- {k.replace('_', ' ').title()}: {v}" for k, v in profile['bio_information'].items()])
        main_profile_section = "\n".join(
            [f"- {trait.title()}: {details['score']} - {details['summary']}" for trait, details in
             profile['main_profile'].items()])
        red_flags_section = "\n".join(
            [f"- {trait.title()}: {details['score']} - {details['summary']}" for trait, details in
             profile['red_flag'].items()])

        motivation_section = "\n".join(
            [f"- {trait.title()}: {details['score']} - {details['summary']}" for trait, details in
             profile['motivation'].items()])

        # Replacing placeholders in the prompts
        prompts = [
            x.replace('{{INDIVIDUAL_NAME}}', individual_name).replace('{{BIO}}', bio_section).replace('{{PROFILE}}',main_profile_section).replace(
                '{{REDFLAGS_PROFILE}}', red_flags_section).replace('{{MOTIVATION_PROFILE}}', motivation_section) for x in prompt_templates]

        # Compiling final prompt
        prompt = "\n".join(prompts)

    except KeyError as e:
        return [{"role": "system", "content": f"Error processing profile data: missing {str(e)}"}]

    message = [
        {"role": "system", "content": prompt_sets[version][0]},
        {"role": "user", "content": prompt}
    ]

    return message


def display_profile_info(profile):
    main_profile = profile["main_profile"]
    red_flag = profile["red_flag"]
    bio_info = profile["bio_information"]

    st.sidebar.markdown("### Bio Information: ")
    st.sidebar.markdown("\n".join([f"- **{key.replace('_', ' ')}**: {value}" for key, value in bio_info.items()]))
    st.sidebar.markdown("### Main Profile: ")
    st.sidebar.markdown("\n".join(
        [f"- **{attribute}**: {details['score']} - {details['summary']}" for attribute, details in
         main_profile.items()]))
    st.sidebar.markdown("### Red Flags: ")
    st.sidebar.markdown("\n".join(
        [f"- **{attribute}**: {details['score']} - {details['summary']}" for attribute, details in red_flag.items()]))
    st.sidebar.markdown("### Motivation: ")
    st.sidebar.markdown("\n".join(
        [f"- **{attribute}**: {details['score']} - {details['summary']}" for attribute, details in profile['motivation'].items()]))


def validate_json(profile):
    required_keys = ['bio_information', 'main_profile', 'red_flag', 'motivation']
    for key in required_keys:
        if key not in profile:
            return False, f"Key '{key}' is missing."
        if not isinstance(profile[key], dict):
            return False, f"'{key}' should be a dictionary."
    return True, "JSON structure is valid."



def logout():
    st.session_state['authenticated'] = False
    st.session_state['profile'] = None
    st.session_state['show_chat'] = None
    st.session_state['analysis'] = None
    st.rerun()


def main_app():
    sidebar_components()

    if st.button('Logout'):
        logout()

    # Streamlit app
    st.title('Metaprofiling\'s Career Insight Analyzer Demo')

    # Check if a profile is selected
    if st.session_state['profile']:
        profile = st.session_state['profile']
        display_profile_info(profile)  # Display the profile information

        st.markdown("""
                ### Generation Temperature
                Adjust the 'Generation Temperature' to control the creativity of the AI responses.
                - A *lower temperature* (closer to 0.0) generates more predictable, conservative responses.
                - A *higher temperature* (closer to 1.0) generates more creative, diverse responses.
            """)
        # Temperature slider
        st.session_state['temperature'] = st.slider("", min_value=0.0, max_value=1.0, value=0.5, step=0.01)

        # Allow user to choose from different versions of the prompt
        st.session_state['version'] = st.selectbox("Select Prompt Version", ["TestTakersSummary", "ManagersSummary"])
        # Generate and display prompt


        if st.button(f'Analyze Profile ({st.session_state["version"]})'):
            # with st.spinner('Generating completion...'):
            prompt = generate_prompt_from_profile(profile, version=st.session_state['version'])

            with st.chat_message("assistant"):
                stream = client.chat.completions.create(
                    model="personality_gpt4o",
                    temperature=st.session_state['temperature'],
                    max_tokens=4096,  # Adjust based on desired response length
                    frequency_penalty=0.2,  # To avoid repetition
                    presence_penalty=0.2,  # To introduce new topics
                    messages=prompt,
                    stream=True)

            response = st.write_stream(stream)
            # st.markdown(response_test_taker)

            st.session_state['analysis'] = response
            st.session_state['show_chat'] = True

            st.rerun()

        # display the response
        if st.session_state['analysis']:
            # Ask for feedback
            st.markdown(st.session_state['analysis'])

            # Ask the user to choose the type of feedback
            feedback_type = st.selectbox(
                "Select the type of feedback:",
                ["Report", "Coach"]
            )

            # Set the dataset identifier based on feedback type
            if feedback_type == "Report":
                dataset_id = "wu981526092/feedback_report"
            else:
                dataset_id = "wu981526092/feedback_coach"

            st.markdown(f"Provide feedback on the {feedback_type.lower()}:")

            criteria = {
                "Faithfulness": "Are all claims made in the answer inferred from the given context, i.e., not hallucinated?",
                "Answer Relevancy": "Is the answer relevant to the question?",
                "Context Relevancy": "Is the context relevant to the question?",
                "Correctness": "Is the answer factually correct, based on the context?",
                "Clarity": "Is the answer explained clearly without the extensive jargon of the original document?",
                "Completeness": "Is the question answered fully, with all parts and subquestions being addressed?",
            }

            ratings = {}
            for criterion, description in criteria.items():
                ratings[criterion] = st.slider(f"{criterion}: {description}", 0, 10, 5,key=f"{feedback_type} {criterion}")

            feedback = st.text_input("Provide additional feedback on the response:",key=f"{feedback_type} feedback")

            if st.button('Submit Report Feedback'):
                if feedback_type == "Report":
                    store_feedback(str(generate_prompt_from_profile(profile, version=st.session_state['version'])), st.session_state['analysis'], feedback, str(ratings), dataset_id)
                else:
                    store_feedback(str(st.session_state['coach_query']), str(st.session_state['coach_response']), feedback, str(ratings), dataset_id)


                st.success("Feedback submitted successfully!")


    else:
        st.write("Please upload a profile JSON file or use the example profile.")


# Function to verify credentials and set the session state
def verify_credentials():
    if st.session_state['username'] == os.getenv("username_app") and st.session_state['password'] == os.getenv(
            "password_app"):
        st.session_state['authenticated'] = True
    else:
        st.error("Invalid username or password")


# Login page
def login_page():
    st.title("Welcome to Metaprofiling's Career Insight Analyzer Demo")
    st.write(
        "This application provides in-depth analysis and insights into professional profiles. Please log in to continue.")

    # Description and Instructions
    st.markdown("""
        ## How to Use This Application
        - Enter your username and password in the sidebar.
        - Click on 'Login' to access the application.
        - Once logged in, you will be able to upload and analyze professional profiles.
    """)

    st.sidebar.write("Login:")
    username = st.sidebar.text_input("Username")  # , key='username')
    password = st.sidebar.text_input("Password", type="password")  # , key='password')

    st.session_state['username'] = username
    st.session_state['password'] = password
    st.sidebar.button("Login", on_click=verify_credentials)


def sidebar_components():
    with st.sidebar:
        if st.button('Reset'):
            st.session_state['profile'] = None
            st.session_state['show_chat'] = None
            st.session_state['analysis'] = None
            st.rerun()

        if not st.session_state['show_chat']:
            # Instructions for JSON format
            st.markdown("### JSON File Requirements:")
            st.markdown("1. Must contain 'bio_information', 'main_profile', and 'red_flag' as top-level keys.")
            st.markdown("2. Both keys should have dictionary values.")

            st.markdown("### Choose the Definition:")
            st.session_state['definition'] = st.selectbox("Select Definition", [1, 2, 3])
            st.session_state['chat_context'] = st.selectbox("Select Chat Context", ["analysis", "profile"])

            # File uploader
            st.markdown("### Upload a profile JSON file")
            uploaded_file = st.file_uploader("", type=['json'])

            if uploaded_file is not None:
                try:
                    profile_data = json.load(uploaded_file)
                    valid, message = validate_json(profile_data)
                    if valid:
                        st.session_state['profile'] = profile_data

                    else:
                        st.error(message)
                except json.JSONDecodeError:
                    st.error("Invalid JSON file. Please upload a valid JSON file.")

            # Button to load example profile
            if st.button('Use Example Profile'):
                if st.session_state['definition'] == 1:
                    file_name = "example_data_definition_1.json"
                elif st.session_state['definition'] == 2:
                    file_name = "example_data_definition_2.json"
                else:
                    file_name = "example_data_definition_3.json"

                with open(file_name, 'r') as file:
                    st.session_state['profile'] = json.load(file)

        else:
            st.sidebar.title("Chat with Our Career Advisor")
            #st.sidebar.markdown(
                #"Hello, we hope you learned something about yourself in this report. This chat is here so you can ask any questions you have about your report!  It’s also a great tool to get ideas about how you can use the information in your report for your personal development and achieving your current goals.")

            # Name to be included in the questions
            # name = st.session_state['profile']['bio_information'].get('Name', 'the individual')

            # List of question templates where {} will be replaced with the name
            question_templates = [
                "What are the main risks associated with {}’s profile?",
                "What are the implications of {}’s profile for working with others?",
                # "What conclusions might we draw from his profile about {}’s style of leadership?",
                # "Looking specifically at {}'s Red Flags, are there any particular areas of concern?",
                # "Based on this profile, is {} better suited as a COO or a CEO?",
                # "If speed of execution is important, based on his profile, how likely is {} to be able to achieve this?",
                # "How is {} likely to react to business uncertainty and disruption?",
                # "Based on his profile, what should a coaching plan designed for {} focus on?"
            ]

            # Formatting each question template with the name
            questions_list = [question.format("Test Taker") for question in question_templates]

            # Prepare the questions for Markdown display
            questions_markdown = "\n\n".join(
                [f"Q{index + 1}: {question}" for index, question in enumerate(questions_list)])

            # Code to display in the app
            st.sidebar.markdown("### Suggest Questions")
            st.sidebar.markdown(questions_markdown)

            # st.sidebar.text_area("Suggested Questions", value=questions.choices[0].message.content, height=200, disabled=True)

            user_input = st.sidebar.text_input("Ask a question about the profile analysis:")

            llm, embed_model = create_models()
            configure_settings(llm, embed_model)
            index = load_documents_and_create_index()

            if st.sidebar.button('Submit'):
                if user_input:
                    st.session_state['coach_query'] = str(user_input)
                    if st.session_state['chat_context'] == "profile":
                        chat_prompt_template = create_chat_prompt_template(get_profile_str(st.session_state['profile']),st.session_state['definition'])
                    else:
                        chat_prompt_template = create_chat_prompt_template(st.session_state['analysis'],st.session_state['definition'])
                    st.session_state['coach_response'] = execute_query(index, chat_prompt_template, user_input)
                    st.sidebar.markdown(st.session_state['coach_response'])



# Initialize session state variables with default values if not already set
session_defaults = {
    'show_chat': None,
    'definition': 1,
    'chat_context': "analysis",
    'profile': None,
    'analysis': None,
    'temperature': 0,
    'version': "",
    'username': '',
    'password': '',
    'authenticated': False,
    'coach_response':"",
    'coach_query':""
}

for key, default in session_defaults.items():
    if key not in st.session_state:
        st.session_state[key] = default

# Show login or main app based on authentication status
if st.session_state['authenticated']:
    main_app()
else:
    login_page()