streamlit_feedback(
    feedback_type="thumbs",
    optional_text_label="[Optional] Please provide an explanation/suggestion",
    max_text_length=512,
    align="flex-start",
    key=f"feedback_{component}_{job_id}",
    on_submit=submit_feedback,
    args=(table, job_id, component),
)

def good_response(conn, input, response):
    cur = conn.cursor()
    cur.execute("INSERT INTO good_responses (question, response) VALUES (%s, %s)", (input, response))
    conn.commit()
    cur.close()

def bad_response(conn, input, response):
    cur = conn.cursor()
    cur.execute("INSERT INTO bad_responses (question, response) VALUES (%s, %s)", (input, response))
    conn.commit()
    cur.close()

with st.expander("Conversation", expanded=True):               
    for i in range(len(st.session_state['generated'])-1, -1, -1):
        st.info(st.session_state["past"][i], icon="🧐")
        st.code(st.session_state["generated"][i])
        feedback = streamlit_feedback(feedback_type=f"thumbs", on_submit=good_response(conn, user_input, answer), key=f"feedback_{i}", optional_text_label="Please type the answer here if the given answer in not correct")
        feedback
        #st.button("👍", on_click=good_response, type='primary', key=f"thumbs_up_{i}", args=(conn, user_input, answer))
        #st.button("👎", on_click=bad_response, type='primary', key=f"thumbs_down_{i}", args=(conn, user_input, answer)) 
        st.header('Follow up questions:')

def handle_feedback():  
    st.write(st.session_state.fb_k)
    st.toast("✔️ Feedback received!")

....

        with st.form('form'):
            streamlit_feedback(feedback_type="thumbs",
                                optional_text_label="[Optional] Please provide an explanation", 
                                align="flex-start", 
                                key='fb_k')
            st.form_submit_button('Save feedback', on_click=handle_feedback)

from langchain.chat_models import AzureChatOpenAI
from langchain.memory import ConversationBufferWindowMemory # ConversationBufferMemory
from langchain.agents import ConversationalChatAgent, AgentExecutor, AgentType
from langchain.callbacks import StreamlitCallbackHandler
from langchain.memory.chat_message_histories import StreamlitChatMessageHistory
from langchain.agents import Tool
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import pprint
import streamlit as st
import os
import pandas as pd
from streamlit_feedback import streamlit_feedback

def handle_feedback():  
    st.write(st.session_state.fb_k)
    st.toast("✔️ Feedback received!")

  
os.environ["OPENAI_API_KEY"] = ...
os.environ["OPENAI_API_TYPE"] = "azure"
os.environ["OPENAI_API_BASE"] = ...
os.environ["OPENAI_API_VERSION"] = "2023-08-01-preview"


@st.cache_data(ttl=72000)
def load_data_(path):
    return pd.read_csv(path) 

uploaded_file = st.sidebar.file_uploader("Choose a CSV file", type="csv")
if uploaded_file is not None:
    # If a file is uploaded, load the uploaded file
    st.session_state["df"] = load_data_(uploaded_file)


if "df" in st.session_state:

    msgs = StreamlitChatMessageHistory()
    memory = ConversationBufferWindowMemory(chat_memory=msgs, 
                                            return_messages=True, 
                                            k=5, 
                                            memory_key="chat_history", 
                                            output_key="output")
    if len(msgs.messages) == 0 or st.sidebar.button("Reset chat history"):
        msgs.clear()
        msgs.add_ai_message("How can I help you?")
        st.session_state.steps = {}
    avatars = {"human": "user", "ai": "assistant"}
    for idx, msg in enumerate(msgs.messages):
        with st.chat_message(avatars[msg.type]):
            # Render intermediate steps if any were saved
            for step in st.session_state.steps.get(str(idx), []):
                if step[0].tool == "_Exception":
                    continue
                # Insert a status container to display output from long-running tasks.
                with st.status(f"**{step[0].tool}**: {step[0].tool_input}", state="complete"):
                    st.write(step[0].log)
                    st.write(step[1])
            st.write(msg.content)


    if prompt := st.chat_input(placeholder=""):
        st.chat_message("user").write(prompt)

        llm = AzureChatOpenAI(
                        deployment_name = "gpt-4",
                        model_name = "gpt-4",
                        openai_api_key = os.environ["OPENAI_API_KEY"],
                        openai_api_version = os.environ["OPENAI_API_VERSION"],
                        openai_api_base = os.environ["OPENAI_API_BASE"],
                        temperature = 0, 
                        streaming=True
                        )

        prompt_ = PromptTemplate(
            input_variables=["query"],
            template="{query}"
        )
        chain_llm = LLMChain(llm=llm, prompt=prompt_)
        tool_llm_node = Tool(
            name='Large Language Model Node',
            func=chain_llm.run,
            description='This tool is useful when you need to answer general purpose queries with a large language model.'
        )

        tools = [tool_llm_node] 
        chat_agent = ConversationalChatAgent.from_llm_and_tools(llm=llm, tools=tools)

        executor = AgentExecutor.from_agent_and_tools(
                                                        agent=chat_agent,
                                                        tools=tools,
                                                        memory=memory,
                                                        return_intermediate_steps=True,
                                                        handle_parsing_errors=True,
                                                        verbose=True,
                                                    )
        

        with st.chat_message("assistant"):            
            
            st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
            response = executor(prompt, callbacks=[st_cb, st.session_state['handler']])
            st.write(response["output"])
            st.session_state.steps[str(len(msgs.messages) - 1)] = response["intermediate_steps"]
            response_str = f'{response}'
            pp = pprint.PrettyPrinter(indent=4)
            pretty_response = pp.pformat(response_str)
              

        with st.form('form'):
            streamlit_feedback(feedback_type="thumbs",
                                optional_text_label="[Optional] Please provide an explanation", 
                                align="flex-start", 
                                key='fb_k')
            st.form_submit_button('Save feedback', on_click=handle_feedback)

def handle_feedback(user_response, emoji=None):
    st.toast(f"Feedback submitted: {user_response}", icon=emoji)
    print(f"test : {user_response}")
    return user_response.update({"some metadata": 123})


feedback_kwargs = {
        "feedback_type": "thumbs",
        "on_submit":handle_feedback
        }
# Generate a new response if last message is not from assistant
if st.session_state.messages[-1]["role"] != "assistant" and st.session_state.messages[-1]["role"] != "system":
    with st.chat_message("assistant"):
        with st.spinner("Thinking..."):
            # log question
            # get response
            chat_history, output = generate_response(prompt)
            placeholder = st.empty()
            full_model_response = ''
            for item in output:
                full_model_response += item
                placeholder.markdown(full_model_response)
            placeholder.markdown(full_model_response)
            streamlit_feedback(
            **feedback_kwargs, key=f"feedback_{int(len(st.session_state.messages)/2)}")

    message = {"role": "assistant", "content": full_model_response}
    st.session_state.messages.append(message)
    streamlit_root_logger.info('=====================================================\n')

def show_chat_messages() -> None:
    """
    Displays the session_state.messages containing the dialog between the user and assistant.
    Assumes that the session has already loaded in messages
    TODO add more metadata to the messages
    """
    for idx, message in enumerate(st.session_state[SessionKeys.MESSAGES.value]):
        with st.chat_message(message.role):
            if message.is_redacted:
                st.write("_content not saved_")
            else:
                st.write(message.content)

        # show feedback for every assistant message
        if message.role == "assistant":
            # send feedback
            if st.session_state[SessionKeys.MESSAGES.value]:
                feedback = streamlit_feedback(
                    feedback_type="faces",
                    optional_text_label="(Optional) Please provide any feedback you have",
                    key=f"feedback-msg-{idx}",
                )
                submit_feedback(
                    feedback,
                    st.session_state.get(SessionKeys.USER_ID.value),
                    st.session_state.get(SessionKeys.CONVERSATION.value),
                    message.message_id,
                )
                ```

Am I just overloading the app with too many calls to feedback?

def handle_feedback():
            st.write(st.session_state.fb_k)
            st.toast("✔️ Feedback received!")

if prompt := st.chat_input(" Ask your document?"):
        st.chat_message("user").markdown(prompt)
        st.session_state.messages.append({"role": "user", "content": prompt})
        with st_lottie_spinner(loading_animation, quality='high', height='70px', width='70px'):
            ans,unique_links = get_response_from_django(prompt)
            with st.chat_message("assistant"):
                st.markdown(ans)

        streamlit_feedback(
                        feedback_type="thumbs",
                        optional_text_label="[Optional] Please provide an explanation",
                        align="flex-start",
                        key=f"fb_k",
                        on_submit=handle_feedback,
            )

            st.write_stream(stream_data(query_result))
            with st.expander("Feedback"):
                feedback_result = streamlit_feedback(
                    feedback_type="thumbs",
                    optional_text_label="[Optional] Please provide an explanation",
                    align="flex-start",
                    on_submit=handle_feedback,
                    args=(query_text, query_result,),
                    key=f"feedback_{query_text}"
                )

                if feedback_result:
                    st.session_state.feedback.append(feedback_result)

uploaded_files = st.sidebar.file_uploader(
    label="Upload PDF files", type=["pdf"], accept_multiple_files=True
)


retriever = configure_retriever(uploaded_files)

# Setup memory for contextual conversation
msgs = StreamlitChatMessageHistory()
memory = ConversationBufferMemory(memory_key="chat_history", chat_memory=msgs, return_messages=True)

# Setup LLM and QA chain
llm = AzureChatOpenAI(callbacks=[trubrics_callback], deployment_name="********",
        model_name="gpt-35-turbo", temperature=0, max_tokens=1024)
qa_chain = ConversationalRetrievalChain.from_llm(
    llm, retriever=retriever, memory=memory, verbose=True
)

if len(msgs.messages) == 0 or st.sidebar.button("Clear message history"):
    msgs.clear()
    msgs.add_ai_message("Hello! I am a Financial Analyst, ready to respond in the language your question is asked in.")

avatars = {"human": "user", "ai": "assistant"}
for msg in msgs.messages:
    st.chat_message(avatars[msg.type]).write(msg.content)
source = st.sidebar.checkbox('I want only the final anwer!')
if user_query := st.chat_input(placeholder="Ask me anything about financial analysis and related questions!"):
    st.chat_message("user").write(user_query)

    with st.chat_message("assistant"):
        retrieval_handler = PrintRetrievalHandler(st.container())
        stream_handler = StreamHandler(st.empty())
        response = qa_chain.run(user_query, callbacks=[retrieval_handler, stream_handler])
        if source:
            st.experimental_rerun()

        st.rerun()

for msg in msgs.messages:
   sender = avatars[msg.type]
   
   content = msg.content
   metadata = {
       "sender": sender,
       
       "content": content
   }

from trubrics.integrations.streamlit import FeedbackCollector

collector = FeedbackCollector(
    project="********",
    email="*******@************",
    password="**********"
)

feedback = collector.st_feedback(
    component="default",
    feedback_type="thumbs",
    model="gpt-3.5-turbo",
    prompt_id=None,  # see prompts to log prompts and model generations
    open_feedback_label='[Optional] Provide additional feedback',
    metadata=metadata
)
if feedback:
    with st.sidebar:
        st.write(":orange[Here's the raw feedback you sent to [Trubrics](https://trubrics.streamlit.app/):]")
        st.write(feedback)

messages = st.session_state.messages

for n, msg in enumerate(messages):
    st.chat_message(msg["role"]).write(msg["content"])

    if msg["role"] == "assistant" and n > 1:
        feedback_key = f"feedback_{int(n/2)}"

        if feedback_key not in st.session_state:
            st.session_state[feedback_key] = None

        test=streamlit_feedback(
            feedback_type="thumbs",
            optional_text_label="Please provide extra information",
            on_submit=_submit_feedback,
            key=feedback_key,
        )
        print(test)
    
if prompt := st.chat_input():
    messages.append({"role": "user", "content": prompt})
    st.chat_message("user").write(prompt)

    if debug:
        st.session_state["response"] = "dummy response"
    else:
        if not openai_api_key:
            st.info("Please add your OpenAI API key to continue.")
            st.stop()
        else:
            pass
        response = "test"
        st.session_state["response"] = "test"
    with st.chat_message("assistant"):
        messages.append(
            {"role": "assistant", "content": st.session_state["response"]}
        )
        st.write(st.session_state["response"])
        st.rerun()

import streamlit as st
from streamlit import session_state as ss
from streamlit_feedback import streamlit_feedback

if 'qr' not in ss:
    ss.qr = None


def ai_response(query):
    ss.qr = "Hey, what's up?" 


with st.form("query_form_k", clear_on_submit=False):
    query = st.text_area("Enter your query")
    st.form_submit_button('Get response', on_click=ai_response, args=(query,))

with st.container():
    st.write('Ai Response:')

    if ss.qr is not None:
        st.write(ss.qr)

with st.container():
    st.write('Your feedback:')

    feedback = streamlit_feedback(
        feedback_type="thumbs",
        optional_text_label="[Optional] Please provide an explanation",
        align="flex-start",
        args=(query),
        key='c1'
    )

    if ss.qr is not None and feedback:
        st.write(feedback)

    st.selectbox(
        'Choose sales framework:',
        ('SPIN', 'Sandler', 'Challenger', 'Miller Heiman'),
        index=None,
        placeholder='Choose an option',
        key='framework_val',
    )
    st.selectbox(
        'Choose tone:',
        ('nice', 'medium', 'tough'),
        index=None,
        placeholder='Choose an option',
        key='tone_val',
    )
    submit_button = st.form_submit_button(label='Submit', on_click=update_params)

if st.session_state.get('role') is None or st.session_state.get('framework') is None or st.session_state.get('tone') is None or st.session_state.get('name') is None:
    return

msgs = StreamlitChatMessageHistory()

if len(msgs.messages) == 0:
    msgs.add_ai_message(f"Hello! I'm your {st.session_state.tone} conversation virtual {st.session_state.role}. Let's get started.")
    
prompt_text = prompt_assembler(st.session_state.role, st.session_state.framework, st.session_state.tone, core_content)
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", prompt_text),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{question}"),
    ]
)
model = ChatOpenAI(
    model="gpt-4-1106-preview", 
    temperature=0, 
    tags=[tag for tag in [st.session_state.name, "virtual_sales_encounter"] if tag is not None]
)
chain = prompt | model

chain_with_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: msgs,  # Always return the instance created earlier
    input_messages_key="question",
    history_messages_key="history",
)

for msg in msgs.messages:
    
    st.chat_message(msg.type).write(msg.content)

    n = st.session_state.count

    if msg.dict()['type'] == 'ai' and n > 1:
    # if msg["role"] == "assistant" and n > 1:
        feedback_key = f"feedback_{st.session_state.count}"

        if feedback_key not in st.session_state:
            st.session_state[feedback_key] = None

        disable_with_score = (
            st.session_state[feedback_key].get("score")
            if st.session_state[feedback_key]
            else None
        )
        streamlit_feedback(
            **feedback_kwargs,
            key=feedback_key,
            disable_with_score=disable_with_score,
        )
    
if prompt := st.chat_input():
    with collect_runs() as cb:
        if not cb.traced_runs or not st.session_state.get('run_id') == 'first_run':
            run_id = 'first_run'
        else:
            run_id = cb.traced_runs[0].id
        st.chat_message("human").write(prompt)
        config = {"configurable": {"session_id": "any"}}
        placeholder = st.empty()  # Create a placeholder for the text
        response_text = ""  # Initialize an empty string
        for s in chain_with_history.stream(
            {"history": history, "question": prompt}, 
              config={
                  "metadata": {
                      "run_id": run_id if st.session_state.get('run_id') is None else st.session_state.run_id
                  }, 
                  "configurable": {
                      "session_id": st.session_state.get('session_id', 'default_session_id')
                  }
              }
        ):
            
            s = s.to_json()
            s = s['kwargs']['content']
            formatted_s = '\n'.join(s[i:i+80] for i in range(0, len(s), 80)) # Insert a newline character every 80 characters
            response_text += formatted_s
            placeholder.markdown(response_text)
        
        if 'run_id' not in st.session_state:
            st.session_state.run_id = run_id
        if st.session_state.get('run_id') == 'first_run' and cb.traced_runs:
            st.session_state.run_id = cb.traced_runs[0].id
        # st.session_state.feedback_id = cb.traced_runs[0].id
  
        # gather_feedback(st)
        streamlit_feedback(
            **feedback_kwargs, key=f"feedback_{st.session_state.count}"
        )
        increment_counter()
st.button('End Conversation', on_click=clear_cache)