Upload 6 files

app.py

@@ -0,0 +1,105 @@
+import streamlit as st
+import re
+import streamlit_authenticator as stauth
+import yaml
+from yaml.loader import SafeLoader
+from streamlit_player import st_player
+from utils import create_transcript_from_youtube_api, create_open_ai_query
+from prompts import DETECT_INTENT_OF_CONVERSATION, TOPIC_BASED_QUESTION, FOLLOW_UP_QUESTION, GENERAL_QUESTION, GENERAL_GREETING, \
+    VAGUE_QUERY_PROMPT
+
+st.set_page_config(page_title="Youtube AI")
+with open('config.yaml') as file:
+    config = yaml.load(file, Loader=SafeLoader)
+
+authenticator = stauth.Authenticate(
+    config['credentials'],
+    config['cookie']['name'],
+    config['cookie']['key'],
+    config['cookie']['expiry_days'],
+    config['preauthorized']
+)
+name, authentication_status, username = authenticator.login()
+
+if st.session_state["authentication_status"]:
+    authenticator.logout('Logout', 'main')
+    st.write(f'Welcome to Mentor Mode')
+elif st.session_state["authentication_status"] is False:
+    st.error('Wrong password or username')
+elif st.session_state["authentication_status"] is None:
+    st.warning('Please enter your username and password')
+    st.session_state["chat_history"] = []
+
+if st.session_state["authentication_status"]:
+    if "chat_history" not in st.session_state:
+        st.session_state["chat_history"] = []
+
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+    with st.sidebar:
+        st.title("Your Video")
+        youtube_video_link = st.text_area("Please enter your video link")
+        st.button("Play Video", type="primary")
+        if youtube_video_link:
+            st_player(youtube_video_link)
+        else:
+            st.write("Please enter a valid link")
+
+    if prompt := st.chat_input("Hey AI!"):
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        st.session_state.chat_history.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+    if youtube_video_link and prompt:
+        with st.spinner("Processing..."):
+            video_id = re.search(r'(?<=v=)[\w-]+', youtube_video_link).group(0)
+            yt_transcript = create_transcript_from_youtube_api(video_id)
+            if yt_transcript["success"]:
+                ADDITIONAL_PROMPT = f"""QUERY : ```{prompt}```, TRANSCRIPT:```{yt_transcript}```, 
+                CHAT_HISTORY:```{st.session_state["chat_history"]}````"""
+                FINAL_PROMPT = ADDITIONAL_PROMPT + DETECT_INTENT_OF_CONVERSATION
+                intent = create_open_ai_query(FINAL_PROMPT)
+                print(intent["data"])
+                if intent["success"]:
+                    if intent["data"] == "VAGUE_QUERY":
+                        FINAL_PROMPT = ADDITIONAL_PROMPT + VAGUE_QUERY_PROMPT
+                        response = create_open_ai_query(FINAL_PROMPT)
+                    elif intent["data"] == "GENERAL_QUESTION":
+                        FINAL_PROMPT = ADDITIONAL_PROMPT + GENERAL_QUESTION
+                        response = create_open_ai_query(FINAL_PROMPT)
+                    elif intent["data"] == "TOPIC_BASED_QUESTION":
+                        FINAL_PROMPT = ADDITIONAL_PROMPT + TOPIC_BASED_QUESTION
+                        response = create_open_ai_query(FINAL_PROMPT)
+                    elif intent["data"] == "FOLLOW_UP_QUESTION":
+                        FINAL_PROMPT = ADDITIONAL_PROMPT + FOLLOW_UP_QUESTION
+                        response = create_open_ai_query(FINAL_PROMPT)
+                    elif intent["data"] == "GENERAL_GREETING":
+                        FINAL_PROMPT = ADDITIONAL_PROMPT + GENERAL_GREETING
+                        response = create_open_ai_query(FINAL_PROMPT)
+
+        with st.chat_message("assistant"):
+            if response["success"]:
+                st.write(response["data"])
+            else:
+                st.write(response["error"])
+        st.session_state.messages.append({"role": "assistant", "content": response["data"]})
+        st.session_state.chat_history.append({"role": "assistant", "content": response["data"]})
+
+    if st.button("Download Chat History"):
+        # Combine role and content for each message
+        chat_history = "\n".join(
+                [f"{message['role']} : {message['content']}" for message in
+                 st.session_state.messages if message["content"] is not None]
+                )
+        st.download_button(
+                label="Download",
+                data=chat_history,
+                file_name="chat_history.txt",
+                mime="text/plain"
+        )

config.yaml

@@ -0,0 +1,13 @@
+credentials:
+  usernames:
+    IssacNewton:
+      email: newton@newtonschool.co
+      name: Issac Newton
+      password: "$2b$12$CnkWEiaUjJTkRvUy4R5R6.UXjHkAxMbwB13AMklpnPcHfdadD9tBK" # To be replaced with hashed password
+cookie:
+  expiry_days: 30
+  key: "issac" # Must be string
+  name: "newton"
+preauthorized:
+  emails:
+  - newton@newtonschool.co

constants.py

@@ -0,0 +1,4 @@
+import os
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+OPENAI_API_BASE_URL = "https://api.openai.com/v1"
+OPEN_AI_MODEL = "gpt-4-1106-preview"

prompts.py

@@ -0,0 +1,29 @@
+DETECT_INTENT_OF_CONVERSATION = """User is watching a youtube video, whose transcript is : TRANSCRIPT. Your task is to classify the type of the given 
+    query : QUERY which is asked by the user. Always take inference from chat history: CHAT_HISTORY, while detecting type.
+    Here are the possible types along with the definition of the type:
+    1.) VAGUE_QUERY: User is asking absolutely irrelevant question which is not present in transcript
+    2.) GENERAL_QUESTION: User is asking in general about the video for eg what is the video about, give me a gist etc
+    3.) TOPIC_BASED_QUESTION: User is asking questions based on specific parts of the video
+    4.) FOLLOW_UP_QUESTION: User is asking follow up questions based on their previous chat history
+    5.) GENERAL_GREETING: User is greeting by saying hi hello thank you.
+    OUTPUT FORMAT -> Just final type, no extra text"""
+
+VAGUE_QUERY_PROMPT = """User is watching a youtube video, whose transcript is : TRANSCRIPT. The previous chat history of the
+user: CHAT_HISTORY. The user had asked a vague query : QUERY. So please tell the user to please stick to a conversation regarding the video
+ only"""
+GENERAL_QUESTION = """User is watching a youtube video, whose transcript is : TRANSCRIPT. The previous chat history of the
+user: CHAT_HISTORY. The user had asked a general question: QUERY regarding the video. Reply the user by taking reference from transcript
+as well from the chat history(if needed). Also be short and crunch , reply with in 100 to 80 words. Give short pointers and be to the point
+"""
+TOPIC_BASED_QUESTION = """User is watching a youtube video, whose transcript is : TRANSCRIPT. The previous chat history of the
+user: CHAT_HISTORY. The user had asked question from a specific part from the video:QUERY. You have to reply to the user by performing
+the following steps internally :
+1.) First understand the question and figure out from which part of the transcript this topic will be.
+2.) Take time to think
+3.) Reply the user accordingly in 100 to 80 words and also be to the point always."""
+
+FOLLOW_UP_QUESTION = """User is watching a youtube video, whose transcript is : TRANSCRIPT. The previous chat history of the
+user: CHAT_HISTORY. The user is asking a follow up question: QUERY based on the chat history. Your task is to analyse the chat history 
+and reply the user accordingly. Always be short and to the point while replying , with in 100 to 80 words"""
+
+GENERAL_GREETING = """User is greeting you : query, please ask the user if they have any question for you!"""

requirements.txt

@@ -0,0 +1,6 @@
+streamlit~=1.31.1
+streamlit-player
+streamlit_authenticator
+pyyaml~=6.0.1
+requests~=2.31.0
+youtube-transcript-api

utils.py

@@ -0,0 +1,32 @@
+from youtube_transcript_api import YouTubeTranscriptApi
+from constants import OPENAI_API_KEY, OPENAI_API_BASE_URL, OPEN_AI_MODEL
+import json
+import requests
+
+def create_transcript_from_youtube_api(youtube_video_id):
+    if not youtube_video_id:
+        return {"success": False, "error": "Please pass your youtube video-id"}
+    try:
+        list_transcript = YouTubeTranscriptApi.get_transcript(youtube_video_id)
+        transcript = ' '.join(entry['text'] for entry in list_transcript)
+        return {"success": True, "data": transcript}
+    except Exception as e:
+        return {"success": False, "error": f"Transcription failed due to : {e}"}
+
+
+def create_open_ai_query(input_query, system_message=None, model_engine=OPEN_AI_MODEL):
+    openai_url = f"{OPENAI_API_BASE_URL}/chat/completions"
+    headers = {'Authorization': f'Bearer {OPENAI_API_KEY}', 'Content-Type': 'application/json'}
+    messages = []
+    if system_message:
+        messages.append({"role": "system", "content": system_message})
+    messages.append({"role": "user", "content": input_query})
+    payload = {
+        'model': model_engine,
+        'messages': messages,
+    }
+    response = requests.post(openai_url, headers=headers, data=json.dumps(payload))
+    if response.status_code == 200 and 'choices' in response.json():
+        content_text = response.json()['choices'][0]['message']['content'].strip()
+        return {"success": True, "data": content_text, "response_json": response.json()}
+    return {"success": False, "error": response.text}