Upload 9 files

AIEMOTBot.py

@@ -0,0 +1,92 @@
+import streamlit as st
+import requests
+import tempfile
+import validators
+import os
+from utils import setup_logging, log_error
+
+# Custom CSS
+with open('styles.css') as f:
+    css = f.read()
+
+st.markdown(f'<style>{css}</style>', unsafe_allow_html=True)
+
+# Setup Logging
+setup_logging()
+
+## FUNCTIONS
+
+# Define function for voicetoemotion page
+def voicetoemotion():
+    st.title("Voice to Emotion")
+    st.subheader("Upload your voice file and detect emotions")
+
+    uploaded_voice = st.file_uploader("Upload a voice file", type=["wav"])
+
+    if uploaded_voice:
+        st.audio(uploaded_voice, format='audio/wav')
+        if st.button("Detect Emotion"):
+            with st.spinner("Detecting emotion..."):
+                voice_path = save_uploaded_voice(uploaded_voice)
+                emotion = detect_emotion_from_voice(voice_path)
+                if emotion:
+                    st.success(f"Emotion detected: {emotion}")
+                else:
+                    st.error("Failed to detect emotion.")
+import streamlit as st
+from utils import detect_emotion_from_voice
+
+# LOGO and TITLE
+# -------------------------------------------------------------------------------------------
+# Show the logo and title side by side
+col1, col2 = st.columns([1, 4])
+with col1:
+    st.image("AIEMOTBOT.png", use_column_width=True,)
+with col2:
+    st.title("Hi, I am AIEMOTBOT - Your Emotional AI Assistant!")
+
+# Main content
+st.header("Upload your voice file and let me detect the emotion!")
+st.subheader("Supported audio formats: WAV, MP3, etc.")
+
+# Function to detect emotion from voice
+def detect_emotion():
+    uploaded_file = st.file_uploader("Upload a voice file", type=["wav", "mp3"])
+    if uploaded_file:
+        st.audio(uploaded_file, format='audio/wav')
+        if st.button("Detect Emotion"):
+            with st.spinner("Detecting emotion..."):
+                emotion = detect_emotion_from_voice(uploaded_file)
+                if emotion:
+                    st.success(f"Emotion detected: {emotion}")
+                else:
+                    st.error("Failed to detect emotion.")
+
+# Call the function to detect emotion
+detect_emotion()
+
+## WEBSITE LINK
+## -------------------------------------------------------------------------------------------
+# Load the website content, then save it into a vector store, and enable the input field to 
+# ask a question
+st.session_state['uploaded_link'] = False
+if website_link is not None:
+    if website_link:
+        # Ensure that the user has entered a correct URL
+        if validators.url(website_link):
+            try:
+                # Send POST request to a FastAPI endpoint to scrape the webpage and load its text 
+                # into a vector store
+                FASTAPI_URL = f"http://localhost:8000/load_link/{llm}"
+                data = {"website_link": website_link}
+                with st.spinner("Loading website..."):
+                    response = requests.post(FASTAPI_URL, json=data)
+                    st.success(response.text)
+                    st.session_state['current_website'] = website_link
+                    st.session_state['uploaded_link'] = True
+                    st.switch_page("pages/Web-chat.py")
+            except Exception as e:
+                log_error(str(e))
+                st.switch_page("pages/error.py")
+        else:
+            st.error("Invalid URL. Please enter a valid URL.")

Dockerfile

@@ -1,24 +1,75 @@
-FROM ghcr.io/livebook-dev/livebook:latest-cuda11.8
-
-ENV LIVEBOOK_APP_SERVICE_NAME "🐳 Hugging Face - $SPACE_TITLE"
-ENV LIVEBOOK_APP_SERVICE_URL "https://huggingface.co/spaces/$SPACE_AUTHOR_NAME/$SPACE_REPO_NAME"
-ENV LIVEBOOK_UPDATE_INSTRUCTIONS_URL "https://livebook.dev"
-ENV LIVEBOOK_WITHIN_IFRAME "true"
-ENV LIVEBOOK_APPS_PATH "/public-apps"
-ENV LIVEBOOK_APPS_PATH_WARMUP "manual"
-ENV LIVEBOOK_DATA_PATH "/data"
-ENV LIVEBOOK_PORT 7860
-
-EXPOSE 7860
-
-RUN mkdir -p /data
-RUN chmod 777 /data
-
-# The Space container runs with user ID 1000
-RUN useradd -m -u 1000 user
-ENV HOME=/home/user
-
-USER user
-
-COPY --chown=user public-apps/ /public-apps
-RUN /app/bin/warmup_apps
+# syntax=docker/dockerfile:1
+
+# Comments are provided throughout this file to help you get started.
+# If you need more help, visit the Dockerfile reference guide at
+# https://docs.docker.com/go/dockerfile-reference/
+
+# Want to help us make this template better? Share your feedback here: https://forms.gle/ybq9Krt8jtBL3iCk7
+
+ARG PYTHON_VERSION=3.11.9
+FROM python:${PYTHON_VERSION}-slim as base
+
+# Prevents Python from writing pyc files.
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Keeps Python from buffering stdout and stderr to avoid situations where
+# the application crashes without emitting any logs due to buffering.
+ENV PYTHONUNBUFFERED=1
+
+# Set the LANGCHAIN PROJECT environment variable
+ENV LANGCHAIN_PROJECT="AIEMOTBot"
+
+WORKDIR /app
+
+# Create a non-privileged user that the app will run under.
+# See https://docs.docker.com/go/dockerfile-user-best-practices/
+ARG UID=10001
+RUN adduser \
+    --disabled-password \
+    --gecos "" \
+    --home "/nonexistent" \
+    --shell "/sbin/nologin" \
+    --no-create-home \
+    --uid "${UID}" \
+    appuser
+
+# Download dependencies as a separate step to take advantage of Docker's caching.
+# Leverage a cache mount to /root/.cache/pip to speed up subsequent builds.
+# Leverage a bind mount to requirements.txt to avoid having to copy them into
+# into this layer.
+RUN --mount=type=cache,target=/root/.cache/pip \
+    --mount=type=bind,source=requirements.txt,target=requirements.txt \
+    python -m pip install -r requirements.txt
+
+# Create a directory named 'data' and assign its ownership to appuser
+RUN mkdir -p /data
+RUN chown appuser /data
+
+# Create a directory named 'images' and assign its ownership to appuser
+RUN mkdir -p /images
+RUN chown appuser /images
+
+# Create the app.log file
+RUN touch app.log
+
+# Assign the ownership of app.log to appuser
+RUN chown appuser app.log
+
+# Switch to the non-privileged user to run the application.
+USER appuser
+
+# Set the TRANSFORMERS_CACHE environment variable
+ENV TRANSFORMERS_CACHE=/tmp/.cache/huggingface
+
+# Create the cache folder with appropriate permissions
+RUN mkdir -p $TRANSFORMERS_CACHE && chmod -R 777 $TRANSFORMERS_CACHE
+
+# Copy the source code into the container.
+COPY . .
+
+# Expose the port that the application listens on.
+EXPOSE 8000
+
+# Run the application.
+# CMD uvicorn 'main:app' --host=0.0.0.0 --port=8000
+CMD ["bash", "-c", "uvicorn main:app --host 0.0.0.0 --port 8000 & streamlit run AIEMOTBot.py --server.port 8501"]

compose.yaml

@@ -0,0 +1,11 @@
+version: '3.8'
+
+# Define services for your application
+services:
+  aiemotbot:
+    # Build the service from the Dockerfile in the current directory
+    build:
+      context: .
+    # Expose port 8000 on the container to port 8000 on the host
+    ports:
+      - "8000:8000"

error.py

@@ -0,0 +1,18 @@
+import streamlit as st
+
+# Custom CSS
+with open('style.css') as f:  # Change 'styles.css' to 'style.css'
+    css = f.read()
+
+st.markdown(f'<style>{css}</style>', unsafe_allow_html=True)
+
+## LOGO and TITLE
+## -------------------------------------------------------------------------------------------
+# Show the logo and title side by side
+col1, col2 = st.columns([1, 4])
+with col1:
+    st.image("AIEMOTBOT.png", width=100)  # Change 'brainbot.png' to 'AIEMOTBOT.png'
+with col2:
+    st.title("Error")
+
+st.error("Oops - Something went wrong! Please try again.")

main.py

@@ -0,0 +1,86 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from contextlib import asynccontextmanager
+from dotenv import load_dotenv
+import base64
+import requests
+import os
+
+## APPLICATION LIFESPAN
+# Load the environment variables using FastAPI lifespan event so that they are available throughout the application
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Load the environment variables
+    load_dotenv()
+    yield
+
+## FASTAPI APP
+# Initialize the FastAPI app
+app = FastAPI(lifespan=lifespan)
+
+## PYDANTIC MODELS
+# Define a Voice Pydantic model for the request body
+class Voice(BaseModel):
+    audio_content: str
+
+## FUNCTIONS
+# Function to encode the audio
+def encode_audio(audio_content):
+    return base64.b64encode(audio_content.encode()).decode('utf-8')
+
+# Function to detect emotion and generate emojis
+def detect_emotion_and_generate_emoji(audio_content):
+    try:
+        # Get the base64 string
+        base64_audio = encode_audio(audio_content)
+        
+        # Make a request to the emotion detection API
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {os.environ['EMOTION_API_KEY']}"
+        }
+
+        payload = {
+            "audio_content": base64_audio
+        }
+
+        response = requests.post("https://api.emotion-analysis.com/detect", headers=headers, json=payload)
+        response_data = response.json()
+        
+        # Process the emotion data and generate emojis
+        # Assuming the response_data contains the detected emotion (e.g., "happy", "sad", "angry", etc.)
+        # You would write logic here to map emotions to emojis
+        
+        # For demonstration, let's assume we have a function to generate emojis based on detected emotion
+        emojis = generate_emojis(response_data['emotion'])
+        
+        return emojis
+    except Exception as e:
+        # Handle errors
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Function to generate emojis based on detected emotion
+def generate_emojis(emotion):
+    # This is just a placeholder function
+    # You would replace this with your actual logic to generate emojis based on the detected emotion
+    if emotion == "happy":
+        return "😊😄🥳"
+    elif emotion == "sad":
+        return "😢😔😞"
+    elif emotion == "angry":
+        return "😡😤🤬"
+    else:
+        return "😐🤔😶"
+
+## FASTAPI ENDPOINTS
+## POST - /detect_emotion
+# Detect emotion from voice content and generate emojis
+@app.post("/detect_emotion")
+async def detect_emotion(voice: Voice):
+    try:
+        # Call the function to detect emotion and generate emojis
+        emojis = detect_emotion_and_generate_emoji(voice.audio_content)
+        return emojis
+    except Exception as e:
+        # Handle errors
+        raise HTTPException(status_code=500, detail=str(e))

requirements.txt

@@ -0,0 +1,19 @@
+bs4
+docx2txt
+faiss-cpu
+fastapi
+langchain
+langchain-community
+langchain-core
+langchain-groq
+langchain-openai
+Pillow
+pydantic
+pypdf2
+python-dotenv
+python-pptx
+requests
+sentence-transformers
+streamlit
+validators
+uvicorn

style.css

@@ -0,0 +1,15 @@
+/* Set border radius for images */
+img {
+    border-radius: 10px;
+}
+
+/* Set background gradient for the entire app */
+.stApp {
+    background: linear-gradient(to bottom, rgba(255, 165, 0, 1) 0%, rgba(255, 192, 203, 1) 100%);
+    /* You can adjust the colors as per your preference */
+}
+
+/* Hide the second item in unordered lists */
+ul li:nth-child(2) {
+    display: none;
+}

utils.py

@@ -0,0 +1,52 @@
+import re
+import os
+import logging
+
+class AIEMOTBot:
+    def __init__(self):
+        self.setup_logging()
+
+    ## LOGGING CONFIGURATION
+    ## -------------------------------------------------------------------------------------------
+    # Configure logging to write to a file
+    def setup_logging(self):
+        logging.basicConfig(filename='app.log', level=logging.ERROR)
+
+    def log_error(self, message):
+        logging.error(message)
+
+    ## HELPER FUNCTIONS
+    ## ------------------------------------------------------------------------------------------
+    # Function to format response received from a FastAPI endpoint
+    @staticmethod
+    def format_response(response_text):
+        # Replace \n with newline character in markdown
+        response_text = re.sub(r'\\n', '\n', response_text)
+
+        # Check for bullet points and replace with markdown syntax
+        response_text = re.sub(r'^\s*-\s+(.*)$', r'* \1', response_text, flags=re.MULTILINE)
+
+        # Check for numbered lists and replace with markdown syntax
+        response_text = re.sub(r'^\s*\d+\.\s+(.*)$', r'1. \1', response_text, flags=re.MULTILINE)
+
+        # Check for headings and replace with markdown syntax
+        response_text = re.sub(r'^\s*(#+)\s+(.*)$', r'\1 \2', response_text, flags=re.MULTILINE)
+            
+        return response_text
+
+    # Function to unlink all images when the application closes
+    @staticmethod
+    def unlink_images(folder_path):
+        # List all files in the folder
+        image_files = os.listdir(folder_path)
+        
+        # Iterate over image files and unlink them
+        for image_file in image_files:
+            try:
+                os.unlink(os.path.join(folder_path, image_file))
+                print(f"Deleted: {image_file}")
+            except Exception as e:
+                print(f"Error deleting {image_file}: {e}")
+
+if __name__ == "__main__":
+    bot = AIEMOTBot()

voicetoemotion.py

@@ -0,0 +1,43 @@
+import streamlit as st
+import speech_recognition as sr
+from textblob import TextBlob
+
+# Initialize Speech Recognition
+recognizer = sr.Recognizer()
+
+# Function to analyze sentiment and generate emoji
+def analyze_sentiment(text):
+    blob = TextBlob(text)
+    sentiment_score = blob.sentiment.polarity
+    if sentiment_score > 0.5:
+        emoji = "😊"
+    elif sentiment_score < -0.5:
+        emoji = "😞"
+    else:
+        emoji = "😐"
+    return emoji
+
+# Streamlit app
+st.title("Voice-to-Text Chatbot")
+
+# Record voice input
+with st.echo():
+    st.write("Click the button and speak...")
+    try:
+        with sr.Microphone() as source:
+            st.write("Recording...")
+            audio_data = recognizer.record(source, duration=5)  # Adjust duration as needed
+            st.write("Processing...")
+
+        # Convert speech to text
+        text = recognizer.recognize_google(audio_data)
+        st.write(f"You said: {text}")
+
+        # Analyze sentiment and generate emoji
+        emoji = analyze_sentiment(text)
+        st.write(f"Sentiment: {emoji}")
+
+    except sr.RequestError as e:
+        st.error("Could not request results; {0}".format(e))
+    except sr.UnknownValueError:
+        st.error("Could not understand audio")