', unsafe_allow_html=True)
st.image("chillbert3.png", caption="Chillbert", use_column_width=True)
st.markdown('
', unsafe_allow_html=True)
with col2:
# Create a centered container
st.markdown('', unsafe_allow_html=True)
st.write("### Ask Chillbert Anything!")
if st.button("Say Hello"):
loop = st.session_state.loop
st.session_state.task = loop.create_task(main())
loop.run_until_complete(st.session_state.task)
if st.button('Stop Conversation'):
ac = AnalyseChat()
ac.setup()
st.session_state['ac'] = ac
print("AC UPDATED")
if st.session_state.task is not None and not st.session_state.task.done():
st.session_state.task.cancel() # Cancel the WebSocket connection task
try:
loop.run_until_complete(st.session_state.task) # Ensure it's fully canceled
except asyncio.CancelledError:
[truncated — 1671 more characters]
```
### chillbert.py
```python
import streamlit as st
import asyncio
import os
from src.authenticator import Authenticator
from src.connection import Connection
from src.analyse_chat import AnalyseChat
from dotenv import load_dotenv
from pyaudio import PyAudio, paInt16
load_dotenv()
# Audio format and parameters
FORMAT = paInt16
CHANNELS = 1
SAMPLE_WIDTH = 2 # PyAudio.get_sample_size(pyaudio, format=paInt16)
CHUNK_SIZE = 1024
# Hardcoded audio device indices and sample rate
INPUT_DEVICE_INDEX = 0 # Replace with correct input device index if needed
OUTPUT_DEVICE_INDEX = 1 # Replace with correct output device index if needed
SAMPLE_RATE = 48000 # Set your desired sample rate
if "task" not in st.session_state:
st.session_state.task = None
if "loop" not in st.session_state:
st.session_state.loop = asyncio.new_event_loop()
# Main asynchronous function
async def main():
"""
Main asynchronous function to set up audio devices, authenticate, and connect to the Hume AI websocket.
"""
# Initialize PyAudio instance
pyaudio = PyAudio()
# Open the audio stream with the selected parameters
audio_stream = pyaudio.open(
format=FORMAT,
channels=CHANNELS,
frames_per_buffer=CHUNK_SIZE,
rate=SAMPLE_RATE,
input=True,
output=True,
input_device_index=INPUT_DEVICE_INDEX,
output_device_index=OUTPUT_DEVICE_INDEX,
)
# Fetch the access token for authentication
access_token = get_access_token()
# Construct the websocket URL with the access token
socket_url = (
"wss://api.hume.ai/v0/assistant/chat?"
f"access_token={access_token}&"
f"config_id=9a7e6382-efba-4cff-9dd2-1d16eceefce2"
)
try:
# Connect to the websocket and start the audio stream
await Connection.connect(
socket_url,
audio_stream,
SAMPLE_RATE,
SAMPLE_WIDTH,
CHANNELS,
CHUNK_SIZE,
)
except asyncio.CancelledError:
st.write("Conversation ended.")
finally:
# Close the PyAudio stream and terminate PyAudio
audio_stream.stop_stream()
audio_stream.close()
pyaudio.terminate()
def get_access_token() -> str:
# Retrieve API key and Secret key from environment variables
HUME_API_KEY = os.getenv("HUME_API_KEY")
HUME_SECRET_KEY = os.getenv("HUME_SECRET_KEY")
if HUME_API_KEY is None or HUME_SECRET_KEY is None:
st.error("HUME_API_KEY and HUME_SECRET_KEY must be set in environment variables.")
st.stop()
authenticator = Authenticator(HUME_API_KEY, HUME_SECRET_KEY)
return authenticator.fetch_access_token()
# def start_convo():
# def end_convo():
def ac_setup():
if 'ac' not in st.session_state:
ac = AnalyseChat()
ac.setup()
st.session_state['ac'] = ac
def chillbert_response(question):
ac = st.session_state['ac']
return ac.askChatbot(question)
st.set_page_config(page_title="Chillbert - Mood-Driven Voice Assistant", layout="wide")
# Add custom CSS for background color and other styles
st.markdown("""
""", unsafe_allow_html=True)
# Sidebar for navigation
#st.sidebar.title("Chillbert")
#st.sidebar.markdown('
Chillbert
', unsafe_allow_html=True)
#st.sidebar.write(':robot_face:')
st.sidebar.image("ChillbertLogo-removebg-preview.png", use_column_width=True)
#st.sidebar.markdown('
CHILLBERT
', unsafe_allow_html=True)
page = st.sidebar.radio("Navigate", ["Start Conversation", "For Practitioners"])
# First Page: Start Conversation with Chillbert
if page == "Start Conversation":
#st.title("Welcome to Chillbert!")
# Layout with two columns
col1, col2 = st.columns(2)
with col1:
# Apply background color to the whole column without affecting the image
st.markdown('
', unsafe_allow_html=True)
# Flexbox to center the image properly
st.markdown('
', unsafe_allow_html=True)
st.markdown("")
st.markdown('
', unsafe_allow_html=True)
with col2:
# Create a centered container
st.write('###')
st.write()
st.markdown('
', unsafe_allow_html=True)
#st.write("### Ask Chillbert Anything!")
loop = st.session_state.loop
st.markdown('
Your emotional sidekick with all the cool vibes!', unsafe_allow_html=T
[truncated — 2597 more characters]
```
### src/messanger.py
```python
from twilio.rest import Client
import os
class Messanger:
def __init__(self):
account_sid = os.environ['TWILIO_ACCOUNT_SID']
auth_token = os.environ['TWILIO_AUTH_TOKEN']
self.client = Client(account_sid, auth_token)
def sendMessage(self, msg, recipient):
if len(msg)>1500:
msg = msg[:1500]
self.client.messages.create(
from_='whatsapp:+14155238886',
body=msg,
to=f'whatsapp:{recipient}'
)
# print("Message sent")
```
### src/remove_audio_data.py
```python
import re
import json
def remove_data_key_from_file(input_file, output_file):
with open(input_file, 'r') as file:
content = file.read() # Read the entire content of the file
# Regular expression to match `'data': ` patterns
cleaned_content = re.sub(r"'data':\s*'[^']*'", '', content)
# Optionally, remove any trailing commas left behind by the removal
cleaned_content = re.sub(r",\s*}", '}', cleaned_content)
with open(output_file, 'w') as file:
file.write(cleaned_content) # Write the modified content to a new file
print(f"Cleaned content saved to {output_file}")
# Usage
input_file = 'audio_responses_log.txt' # Replace with the path to your input file
output_file = 'audio_responses_cleaned.txt' # Replace with the desired output file path
remove_data_key_from_file(input_file, output_file)
```
### src/text_to_pdf.py
```python
from fpdf import FPDF
class PDF(FPDF):
def __init__(self):
super().__init__()
# Add Arial Unicode font during initialization
self.add_font("ArialUnicode", "", "/Library/Fonts/Arial Unicode.ttf")
def header(self):
# Set the font for the header after it's added
self.set_font("ArialUnicode", "", 12)
self.cell(0, 10, "Text to PDF Conversion", 0, 1, "C")
def txt_to_pdf(txt_file, pdf_file):
pdf = PDF()
pdf.add_page()
# Set the same font for the main content
pdf.set_font("ArialUnicode", "", 12)
# Read the .txt file and add its content to the PDF
with open(txt_file, 'r', encoding='utf-8') as file:
for line in file:
pdf.multi_cell(0, 10, line)
# Save the PDF
pdf.output(pdf_file)
print(f"PDF saved at: {pdf_file}")
txt_file = "audio_responses_cleaned.txt" # Replace with your .txt file path
pdf_file = "audio_responses_cleaned.pdf" # Desired .pdf file path
txt_to_pdf(txt_file, pdf_file)
```
### src/llm_learns.py
```python
import openai
# Set your OpenAI API key
from openai import OpenAI
# Sample content to include in the system prompt
with open("audio_responses_cleaned.txt", "r", encoding="utf-8") as file:
sample_content = file.read()
def fetch_answer(user_input):
# Initialize the OpenAI client
client = OpenAI(
# This is the default and can be omitted
api_key=openai.api_key
)
# Creating the chat completion request
response = client.chat.completions.create(
model="gpt-3.5-turbo", # Model selection
messages=[
{
"role": "system",
"content": f"You will be provided with a question, and you have to fetch insights for the same from {sample_content}"
},
{
"role": "user",
"content": user_input
}
],
temperature=0.2, # Controls randomness: lower values make output more focused
max_tokens=1000, # Limits the response length
top_p=1.0, # Nucleus sampling; 1.0 means no filtering
)
# Print the model's response
print(response.choices[0].message.content)
user_input=input("Enter your question: ")
fetch_answer(user_input)
```
### src/llm_learns_vertex.py
```python
import streamlit as st
#Gen AI code
import markdown
import pathlib
import textwrap
import google.generativeai as genai
from IPython.display import display
from IPython.display import Markdown
# Or use `os.getenv('GOOGLE_API_KEY')` to fetch an environment variable.
model = genai.GenerativeModel('gemini-pro')
genai.configure(api_key=GOOGLE_API_KEY)
for m in genai.list_models():
if 'generateContent' in m.supported_generation_methods:
print(m.name)
with st.form("get_recommendation"):
st.write("What would you like to watch today?")
search = st.text_input('', '')
submitted = st.form_submit_button("Submit")
if submitted:
confirm=model.generate_content("is the following sentence asking for movie recommendation "+search+".If yes, then is the confidence percentage greater than or equal to 90. Only say yes or no")
print("Related to movies, yes or no?",confirm.text)
percentage=confirm.text
if percentage=="yes":
response = model.generate_content(search)
answer=response.text
markdown.markdown(answer)
st.write(answer)
else:
st.write("I'm not sure if what you are searching for is related to movies? Could you please check again?")
if submitted:
st.write("Hope you like these recommendations! Enjoy with popcorn and a soda!")
```
### src/analyse_chat.py
```python
from src.fileprocessing import FileProcessing
from src.chatbot import ChatBot
from src.messanger import Messanger
import os
from dotenv import load_dotenv
load_dotenv()
class AnalyseChat:
def __init__(self):
self.fp = FileProcessing('logs/emotion_logs')
self.m = Messanger()
self.setup_complete=False
def setup(self):
print('Setting up Chat Analysis')
output_file = self.fp.processFile()
self.cb = ChatBot(output_file)
summary = self.cb.summarize()
links = self.cb.getlinks(summary)
self.sendChatSummary(summary)
self.sendHelpfulLinks(links)
print('sent messages')
# self.cb.ask_anything_continuous()
def sendChatSummary(self, summary_message):
msg = f'Your patient XYZ recently spoke to me. Here is the summary of our conversation. \n{summary_message}'
self.m.sendMessage(msg, os.environ['TWILIO_RECIPIENT'])
def sendHelpfulLinks(self, link_message):
msg = f'I really enjoyed our converation today. Based on our chat, here are a few helpful links for you!\n{link_message}'
self.m.sendMessage(msg, os.environ['TWILIO_RECIPIENT'])
def askChatbot(self, question):
resp = self.cb.ask_anything(question)
# print(f'Response:{resp}')
return resp
# ac = AnalyseChat()
# ac.setup()
# print(ac.askChatbot('How are the users emotions?'))
```
[6 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]