initial commit

app.py

@@ -0,0 +1,291 @@
+import gpt4
+import gpt3
+from time import sleep
+from asyncio import run
+from langchain.prompts import PromptTemplate
+from utils import *
+import streamlit as st
+from pathlib import Path
+from streamlit_option_menu import option_menu
+
+question_prompt_template = """
+    You are very good at handling very long texts,so I will give you a video transcription splitted in small pieces,this is piece number {i}.You will get a query about it,\n\n
+    transcription: {input}\n\n
+    
+    query: {question}    \n\n
+    feel free to neglect the given transcription if you see that the query is not related to it like thank you or ok and similars, provide instead an appropriate answer like you are welcome.
+    query may be a question about it or not, do your best to extract the answer if it exists or make up a suitable answer but hint me if you made one(say for example This answer is not mentioned but and this is a made one).
+    or it can be explaining something in a simpler way,
+    or it can be writing programming code explaining a concept in it,
+    or summerizing it in number of words,
+    or splitting it to chapters of homogenious content like youtube does.Do your best to give me the answer in this format "hr:min:sec title" and make sure that each chapter is at least 3 minutes.
+    or any query
+    you may be asked to provide your answer in specific language like arabic, and you must provide your answer in the asked language.
+    Also you may be provided with the previous query and a summary of your answer to use them like a memory of past interactions.
+    You can neglect them if you see that the answer of the current query doesn't need them.
+        
+    Your answer:\n\n
+    """
+
+prompt = PromptTemplate(input_variables=["i","input", "question"], template=question_prompt_template)
+
+async def get_answer(question):
+    try:
+        resp = await gpt4.Completion().create(question)
+        return resp
+        
+    except:
+        try:
+            resp = await gpt3.Completion().create(question)
+            return resp
+        except:
+            st.info('Service may be stopped or you are disconnected with internet. Feel free to open an issue here "https://github.com/Mohamed01555/VideoQuERI"')
+            st.stop()
+
+def img_to_bytes(img_path):
+    img_bytes = Path(img_path).read_bytes()
+    encoded = base64.b64encode(img_bytes).decode()
+    return encoded
+
+def main():
+    # setup streamlit page
+    st.set_page_config(
+        page_title="VideoQuERI",
+        page_icon="vqueri.jpeg")
+    
+    option = option_menu(
+    menu_title=None,
+    options=["Home", "FAQs", "Contact", "Donate"],
+    icons=["house-check", "patch-question-fill", "envelope","currency-dollar"],
+    orientation='horizontal',
+    styles={
+        "container": {"padding": "0!important", "background-color": "#333"},        
+        "icon": {"color": "orange", "font-size": "25px"}, 
+        "nav-link": {"font-size": "25px", "text-align": "left", "margin":"0px", "--hover-color": "#ff9900"},
+        "nav-link-selected": {"background-color": "#6c757d"},
+    }
+    )   
+
+    st.markdown(page_bg_img, unsafe_allow_html=True)
+    st.markdown(html_code, unsafe_allow_html=True)
+
+    # initialize responses.
+    if "responses" not in st.session_state:
+        st.session_state.responses = []
+    
+    # initialize caption.
+    if "caption" not in st.session_state:
+        st.session_state.caption = None
+
+    # initialize test_splitter.
+    if "text_splitter" not in st.session_state:
+        text_splitter = None
+    
+    # Initialize session state variables
+    if 'captions' not in st.session_state:
+        st.session_state.captions = {}
+
+    # initialize chunks.
+    if "chunks" not in st.session_state:
+        st.session_state.chunks = None
+    
+    if "button_pressed" not in st.session_state:
+        st.session_state.button_pressed = False
+    
+    if "chosen_chunks" not in st.session_state:
+        st.session_state.chosen_chunks = []
+
+    if "prev_qa" not in st.session_state:
+        st.session_state.prev_qa = None
+    
+    if 'video_url_list' not in st.session_state:
+        st.session_state.video_url_list = []
+
+    if "question" not in st.session_state:
+        st.session_state.question = None
+
+    if "chosen_radio" not in st.session_state:
+        st.session_state.chosen_radio = None
+
+    # Set the maximum number of stored captions
+    MAX_CAPTIONS = 10
+
+    with st.sidebar:
+        video_url = st.text_input("**Paste the video url here:**")
+        
+        help_slider= "Processing the entire video in a single iteration might be beyond the capability of GPT.\
+                So we split it in chunks. Please choose the desired chunk size. The bigger the chunk size is, the more precise the answer you get."
+        selected_value = st.slider("Select a value for chunk size", min_value=100, max_value=3000, value=1500, step=1, help=help_slider)
+        
+        help_button = "Creating captions from scratch for a video lasting one hour typically requires approximately 2 minutes.\n \
+                       In the event of the server experiencing a high volume of requests, the caption generation process could become significantly delayed.\
+                       If this occurs, we recommend revisiting at a different time. Alternatively, if you already possess the caption, please feel free to provide it below."
+        
+        if st.button("Generate the Caption...", help = help_button):
+            st.session_state.button_pressed = True
+            if (video_url.strip().startswith('http') or video_url.strip().startswith('https')):
+                with st.spinner("Generating the video Caption..."):
+                    if video_url not in st.session_state.captions.keys():
+                        st.session_state.caption, ret = get_transcript(video_url)
+                        
+                        if st.session_state.caption:
+                            if ret == 'return_from_whisper':
+                                st.session_state.captions[video_url] = st.session_state.caption
+                            text_splitter = TokenTextSplitter(chunk_size = selected_value, chunk_overlap=11)
+                            st.session_state.chunks = text_splitter.split_documents(st.session_state.caption)
+                            
+                            #add the url to the list to ensure whether i will provide a summary of perious qa                            
+                            st.info("Caption was generated successfully. You can ask now.")
+                        
+                        else:
+                            st.info('Most likely it is not a video, Or caption eneration service if full now. Please try again later')
+                            st.stop() 
+                    else:
+                        st.session_state.caption = st.session_state.captions[video_url]
+                        text_splitter = TokenTextSplitter(chunk_size = selected_value, chunk_overlap=11)
+                        st.session_state.chunks = text_splitter.split_documents(st.session_state.caption)
+                    
+                        #add the url to the list to ensure whether i will provide a summary of perious qa    
+                        st.info("Caption was generated successfully. You can ask now")
+
+                        
+                    # Limit the number of stored captions
+                    if len(st.session_state.captions) > MAX_CAPTIONS:
+                        oldest_url = next(iter(st.session_state.captions))
+                        st.session_state.captions.pop(oldest_url)
+                
+            else:
+                st.info('Valid URL must start with `http://` or `https://` ')
+                st.stop()
+        
+        if st.session_state.button_pressed:
+            t=''
+            for c,doc in enumerate(st.session_state.chunks):        
+                start, end = extract_start_end_time(doc.page_content)
+                if start is not None and end is not None:  
+                    t += f'Chunk {c+1} : from {start} to {end}\n\n'
+            with st.expander('**Info :information_source:**'):
+                st.info(
+                    f'Number of Chunks : {len(st.session_state.chunks)}\n\n{t}'
+                    )
+
+            with st.expander("**If your query is about specific chunks, please choose them** :slightly_smiling_face:"):
+
+                st.session_state.chosen_chunks = []
+                for i in range(len(st.session_state.chunks)):
+                    chosen_chunk = st.checkbox(label= str(i+1))
+                    if chosen_chunk:
+                        st.session_state.chosen_chunks.append(i + 1)
+
+            if st.session_state.chosen_chunks:
+                st.info(f"Selected Chunks: {st.session_state.chosen_chunks}")
+
+        st.session_state.chosen_radio = st.radio("Do you wnat to add some sort of memory?", ['No', 'Yes'], help="Note that it is not that accurate memory")
+           
+    if option == 'Home':
+        for response in st.session_state.responses:
+            with st.chat_message(response['role']):
+                st.markdown(response['content'], unsafe_allow_html=True)
+
+
+        st.session_state.question = st.chat_input('Your Query...')
+        if st.session_state.question:
+            if not st.session_state.button_pressed:
+                st.info("You forgot to enter your Video URL and click *Generate the Caption...* button.")
+                st.stop()
+
+            with st.chat_message('user'):
+                st.markdown(st.session_state.question,unsafe_allow_html=True)
+
+            st.session_state.responses.append({'role':"user", 'content': st.session_state.question})
+            
+            with st.chat_message('assistant'):
+                st.session_state.message_placeholder = st.empty()
+                full_response = ''
+                #if the user entered specefic chunks to query about
+                if len(st.session_state.chosen_chunks) != 0:
+                    for c in st.session_state.chosen_chunks: 
+                        doc = st.session_state.chunks[c-1] 
+                        # full_response = answer(chunk_number=c, doc = doc, question = question)
+                        query = prompt.format(i = c, input = doc.page_content, question = st.session_state.question)
+                        
+                        try:
+                            if video_url == st.session_state.video_url_list[-1]:
+                                query += st.session_state.prev_qa if st.session_state.prev_qa else ''
+                        except:
+                            query = query
+                        start, end = extract_start_end_time(doc.page_content)
+                        if start is not None and end is not None:  
+                            with st.spinner(f"Searching for the answer in the period {start} --> {end}"):
+                                ai_response = run(get_answer(query))
+                                ai_response_decoded = decode_unicode(ai_response)
+                                time_ = f"""<span style="color: #00FF00;">Answer in the period <span style="color: #800080;">{start} --> {end}</span> is \n\n</span>"""
+                                full_response += '\n' + time_ + '\n'+ ai_response_decoded + '\n'
+  
+                                st.session_state.message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
+                                    
+                        
+                        else:
+                            ai_response = run(get_answer(query))
+                            ai_response_decoded = decode_unicode(ai_response)
+                            full_response += '\n\n' + ai_response_decoded + '\n\n'
+                        
+                            st.session_state.message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
+                            
+                
+                #if the user did not entered specefic chunks, use all chunks
+                else:
+                    for c,doc in enumerate(st.session_state.chunks):     
+                        # full_response = answer(chunk_number=c+1, doc = doc, question = question)   
+                        query = prompt.format(i = c+1, input = doc.page_content, question = st.session_state.question)
+                        
+                        try:
+                            if video_url == st.session_state.video_url_list[-1]:
+                                query += st.session_state.prev_qa if st.session_state.prev_qa else ''
+                        except:
+                            query = query
+                        
+                        start, end = extract_start_end_time(doc.page_content)
+                        if start is not None and end is not None:  
+                            with st.spinner(f"Searching for the answer in the period {start} --> {end}"):
+                                ai_response = run(get_answer(query))
+
+                                ai_response_decoded = decode_unicode(ai_response)
+                                time = f"""<span style="color: #00FF00;">Answer in the period <span style="color: #800080;">{start} --> {end}</span> is \n\n</span>"""
+                                full_response += '\n' + time + '\n'+ ai_response_decoded + '\n'
+                                
+                                st.session_state.message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
+                        
+                        else:
+                            ai_response = run(get_answer(query))
+                            ai_response_decoded = decode_unicode(ai_response)
+                            full_response += '\n' + ai_response_decoded
+                            
+                            st.session_state.message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
+                
+                st.session_state.message_placeholder.markdown(full_response, unsafe_allow_html=True)
+                
+                if st.session_state.chosen_radio == 'Yes':
+                    # get a summary of the answer and append before the next question
+                    summary_prompt = f"""
+                    Please summarize this in 100 to 200 words as a mximum.
+                    Retain any programming code present, even if doing so exceeds the 200-word limit.
+                    Capture the entites if exist\n{full_response}
+                    """
+                    summary = run(get_answer(summary_prompt))
+                    st.session_state.prev_qa = f"This is the previous question: {st.session_state.question}\nand this is the summary of your answer: {summary}"
+                
+                            
+            st.session_state.video_url_list.append(video_url)
+
+            st.session_state.responses.append({'role' : 'assistant', 'content' : full_response})
+
+    elif option == 'FAQs':
+        FAQs()
+    elif option == 'Contact':
+        contact()
+    else:
+        donate()
+
+if __name__ == '__main__':
+    main()

gpt3.py

@@ -0,0 +1,66 @@
+from aiohttp import ClientSession, ClientError
+from json import loads, JSONDecodeError
+
+
+class Completion:
+    """
+    This class provides methods for generating completions based on prompts.
+    """
+
+    async def create(self, prompt):
+        """
+        Create a new completion based on the given prompt.
+
+        Args:
+            prompt (str): The prompt to generate a completion for.
+
+        Returns:
+            str: The generated completion.
+
+        Raises:
+            Exception: If unable to fetch the response.
+        """
+        try:
+            async with ClientSession() as session:
+                async with session.post(
+                    "https://ava-alpha-api.codelink.io/api/chat",
+                    headers={"Content-Type": "application/json"},
+                    json={
+                        "model": "gpt-4",
+                        "temperature": 0.6,
+                        "stream": True,
+                        "messages": [
+                            {
+                                "role": "system",
+                                "content": "You are Ava, an AI assistant.",
+                            },
+                            {"role": "user", "content": prompt},
+                        ],
+                    },
+                    timeout=45,
+                ) as resp_obj:
+                    resp = ""
+                    async for line in resp_obj.content:
+                        line_text = line.decode("utf-8").strip()
+                        if line_text.startswith("data:"):
+                            data = line_text.split("data:")[1]
+                            try:
+                                data_json = loads(data)
+                                if "choices" in data_json:
+                                    choices = data_json["choices"]
+                                    for choice in choices:
+                                        if (
+                                            "finish_reason" in choice
+                                            and choice["finish_reason"] == "stop"
+                                        ):
+                                            break
+                                        if (
+                                            "delta" in choice
+                                            and "content" in choice["delta"]
+                                        ):
+                                            resp += choice["delta"]["content"]
+                            except JSONDecodeError:
+                                pass
+                    return resp
+        except:
+            raise Exception("Unable to fetch the response.")

gpt4.py

@@ -0,0 +1,62 @@
+from uuid import uuid4
+from re import findall
+import tls_client
+
+class Completion:
+    async def create(self, prompt):
+        """
+        Create a completion for the given prompt using the you.com API.
+
+        Args:
+            prompt (str): The prompt for which completion is requested.
+            proxy (str, optional): The proxy to be used for the API request. Defaults to None.
+
+        Returns:
+            str: The completion result as a string.
+
+        Raises:
+            Exception: If unable to fetch the response or the required token from the response.
+        """
+        client = tls_client.Session(client_identifier="chrome_108")
+        client.headers = {
+            "authority": "you.com",
+            "accept": "text/event-stream",
+            "accept-language": "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
+            "cache-control": "no-cache",
+            "referer": "https://you.com/search?q=who+are+you&tbm=youchat",
+            "sec-ch-ua": '"Not_A Brand";v="99", "Google Chrome";v="109", "Chromium";v="109"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "cookie": f"safesearch_guest=Off; uuid_guest={str(uuid4())}",
+            "user-agent": "Mozilla/5.0 (Windows NT 5.1; U;  ; rv:1.8.1) Gecko/20061208 Firefox/2.0.0 Opera 9.52",
+        }
+        params = {
+            "q": prompt,
+            "page": 1,
+            "count": 10,
+            "safeSearch": "Off",
+            "onShoppingPage": False,
+            "mkt": "",
+            "responseFilter": "WebPages,Translations,TimeZone,Computation,RelatedSearches",
+            "domain": "youchat",
+            "queryTraceId": str(uuid4()),
+            "chat": [],
+        }
+        resp = client.get(
+            "https://you.com/api/streamingSearch", params=params, timeout_seconds=30
+        )
+        
+        print("Response Status Code:", resp.status_code)
+        print("Response Text:", resp.text)
+
+        if "youChatToken" not in resp.text:
+            raise Exception("Unable to fetch response.")
+        return (
+            "".join(findall(r"{\"youChatToken\": \"(.*?)\"}", resp.text))
+            .replace("\\n", "\n")
+            .replace("\\\\", "\\")
+            .replace('\\"', '"')
+        )

requirements.txt

@@ -0,0 +1,9 @@
+gradio_client==0.4.0
+langchain==0.0.268
+tiktoken==0.4.0
+pytube==15.0.0
+streamlit==1.25.0
+streamlit_option_menu==0.3.6
+youtube_transcript_api==0.6.1
+yt_dlp==2023.3.4
+tls-client == 0.2.1

utils.py

@@ -0,0 +1,235 @@
+from youtube_transcript_api import YouTubeTranscriptApi
+import streamlit as st
+from langchain.docstore.document import Document
+from langchain.text_splitter import TokenTextSplitter
+import re
+import base64
+from whisper_result import *
+
+def postprocess_time_if_transcript_was_already_generated(time):
+    if time < 60:
+        sec = int(time)
+        return f'0:{sec}'
+    
+    hour = int(time) // 3600
+    min = int(time) // 60
+    sec = int(time) % 60 
+    if hour == 0:
+        return f'{min}:{sec}'
+    else:
+        return f"{hour}:{abs(hour*60 - min)}:{sec}"
+    
+def ret_trans(vid):
+    # retrieve the available transcripts
+    transcript_list = YouTubeTranscriptApi.list_transcripts(vid)
+
+    # iterate over all available transcripts
+    for transcript in transcript_list:
+        if 'en' in transcript.language_code:
+            return transcript.fetch()
+
+        elif transcript.is_translatable and 'en' in [t['language_code'] for t in transcript.translation_languages]:
+            return transcript.translate('en').fetch()
+        
+        else:
+            return transcript.fetch()
+        
+def get_generated_transcript(video_url):
+    video_id = video_url.split('=')[1]
+    res = ret_trans(video_id)
+    
+    transcript = ', '.join([f"{postprocess_time_if_transcript_was_already_generated(t['start'])} {t['text']}" for t in res])
+    transcript = [Document(page_content=transcript)]
+
+    return transcript
+
+def extract_start_end_time(passage):
+    time_pattern = r'\d{1,2}:\d{1,2}(?::\d{1,2})?'
+    
+    times = re.findall(time_pattern, passage)
+    # print(times)
+    if len(times) >= 2:
+        start_time = times[1]
+        end_time = times[-2]
+        # print(times)
+        return start_time, end_time
+    else:
+        return None, None
+
+def decode_unicode(text):
+    return bytes(text, "utf-8").decode("unicode-escape")
+
+def get_transcript(video_url):    
+    try:  #if the transcript was alrady generated
+        transcript = get_generated_transcript(video_url)
+        return transcript, 'return_from_generated_transcript'
+    except:
+        st.info("Looks like the provided video does not have transcription. Plese be patient until transcription is generated.")
+        s = time.time()
+        transcript = get_whisper_result(video_url)
+        if transcript:
+            st.info(f"Generating Caption took {round(time.time() - s, 2)} seconds")
+            return [Document(page_content=transcript)], 'return_from_whisper'
+        
+        else:
+            return False, ''
+
+# Define your FAQ questions and answers
+def FAQs():
+    faq = {
+        "What is VideoQuERI?":"It is a versatile and interactive website that utilizes AI capabilities to process videos, answer questions, generate code, solve puzzles, and perform mathematical operations.\
+        It depends that the video is described in someone's voice not visually. If the video's description is solely visual, the algorithm will not function effectively.",
+
+        "What are the Capabilities of VideoQuERI?<ul>" :
+        " <li>**Video Processing**: Users can input video URLs to your website. The AI can then process these videos to extract information, such as speech recognition for transcriptions.</li>"
+        " <li>**Question Answering**:Users can ask questions related to the video's content. The website's AI can analyze the video's transcriptions and content to provide relevant answers to users' questions.</li>"
+        " <li>**Code Generation**: If the video contains step-by-step instructions for coding, AI can extract these instructions and generate code snippets.</li>"
+        " <li>**Generating Chapters**: You can ask the bot to help you splitting your video to chapters.</li>"
+        " <li>**Puzzle Solving**: Videos with puzzle verbally instructions can be processed by the AI to understand the rules and mechanics. Users can input puzzle-specific queries, and it can provide solutions or hints.</li>"
+        " <li>**Memory**: Chatbot has memory to retain and recall information from previous parts of the conversation. But,honestly, it is not that strong.</li>"
+        " <li>**Information Retrieval** : If you forget when a piece of information was said, you can provide the video and your question.</li>"
+        " <li>**Educational Content**: Your website can serve as an educational platform by offering explanations, demonstrations, and tutorials on various subjects based on the video content.</li>"
+        " <li>**Natural Language Understanding**: The AI can understand and analyze the natural language used in both the video's transcriptions and user queries. This allows for more contextually accurate responses.</li>"
+        " <li>**Interactive UI**: Your website's user interface can incorporate elements like text input fields, and result displays to make the interactions intuitive and engaging.</li>"
+        " <li>**Scalability**: The AI-driven capabilities can be applied to various types of videos, making your website versatile and adaptable to different content.</li> </ul> "        
+          ,
+    
+        "What if the user has already generated transcription (e.g. from platforms like Coursera or Udemy)?":
+        "You can copy it and ask ChatGPT or Poe",
+        
+        "what if Caption generation took a long time?":"There are two propable reasons. First, the video url is not supported. Second, the transcription generation API has too many requuests\
+         If the first case, then the video may be streamed to wesite in .ts format , and .ts is not supported .However,if your case is the second case, you can visit the us after a period of time.",
+        
+        "What if the video is in your local machine?":"You can Upload it to your google drive and then share the link with us.",
+        
+        "What are supported formats?" :
+        "However, most video formats are supported, streaming videos in the .ts format (Transport Stream) are currently not compatible with our system.\
+         Transport Stream is a container format often used for streaming live broadcasts and might require specialized processing.\
+         If you have a .ts format video, you might consider converting it to a supported format using 'ffmpeg' and upload it to your drive and share the link with us.\
+         We appreciate your understanding and are here to assist you with any questions you may have! ",
+        
+        "How can I get the video link?":
+        """You should install this <a href="https://chrome.google.com/webstore/detail/video-downloadhelper/lmjnegcaeklhafolokijcfjliaokphfk?hl=es">chrome extension</a>, \
+           <a href = "https://addons.mozilla.org/en-US/firefox/addon/video-downloadhelper/">firefox extension</a>.\
+           If you are in the webpage that has the desired video click on the extension logo , a menu will be listed , click copy url, finally paste in the video url input field.
+        """ ,
+
+        "What languages are supported?" : 
+        "Afrikaans, Arabic, Armenian, Azerbaijani, Belarusian, Bosnian, Bulgarian, Catalan, Chinese, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French,\
+         Galician, German, Greek, Hebrew, Hindi, Hungarian, Icelandic, Indonesian, Italian, Japanese, Kannada, Kazakh, Korean, Latvian, Lithuanian, Macedonian, Malay, Marathi,\
+         Maori, Nepali, Norwegian, Persian, Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovenian, Spanish, Swahili, Swedish, Tagalog, Tamil, Thai, Turkish, Ukrainian, Urdu, Vietnamese, and Welsh.",
+        
+        "Is there a tip to get the most out of VideoQuERI":"Yes, you should ask your question in English and ask the bot to answer in your favourite language(e.g. What is this video about? answer in 'arabic').",
+        
+        "What is the purpose of the video URL field?":
+        "The video URL field allows you to input the URL of the video you want to query.Our system will analyze the video content to provide relevant answers.",
+
+        "How do I input a video URL, especially for platforms like Facebook or embedded videos?":
+        "To input a video URL, simply copy the URL of the video you want to query and paste it into the video URL field.",
+
+        "What is the chunk size slider for?":
+        "The chunk size slider lets you adjust the size of video segments that the system analyzes. This can help you get more focused and precise answers based on specific parts of the video.",
+
+        "How does the system generate answers from the video?":
+        "Our system uses advanced AI technology to analyze the video's audio content. It then generates answers based on the context and content of the video.",
+
+        "Is there a limit to the video length I can query?":
+        "While there's generally no strict limit on video length, very long videos might take longer to process. It's recommended to choose appropriate chunk sizes for efficient processing and accurate answers.",
+
+        "Can I change the chunk size while the video is being processed?":
+        "No, you can adjust the chunk size slider after generating the caption then click `Generate the Caption` button again . This allows you to explore different parts of the video and get answers for specific segments.",
+
+        "Can I ask questions while the caption is being generated?":
+        "No, you can ask questions after the caption generation is completed.",
+
+        "How accurate are the answers generated from the video?":
+        "The accuracy of answers depends on various factors such as the clarity of the audio, and the specificity of your questions. Generally, the system strives to provide relevant and coherent answers.",
+
+        "Can I save or bookmark specific answers from the video?":
+        "At the moment, the system doesn't offer direct saving or bookmarking of answers. However, you can take screenshots or notes to keep track of important information.",
+
+        "Are there certain types of videos that work better with this feature?":
+        "The system is designed to work with a wide range of videos, but videos with clear audio tend to yield better results. Educational, instructional, and well-structured videos are usually more suitable."
+
+
+    }
+    # with st.expander("FAQs"):
+    for i, faq_key in enumerate(faq.keys()):
+        # with st.sidebar.expander(faq_key):
+        st.write(f"**Q{i+1}. {faq_key}**\n \n**Answer** : {faq[faq_key]}", unsafe_allow_html=True)
+        st.write('-'*50)
+
+def contact():
+    mail = """<h2><a href="mailto:[email protected]">Email</a></h2>"""
+    linkedin = """<h2><a href="https://www.linkedin.com/in/mohamed-algebali-213672173/">Linkedin</a></h2>"""
+
+    con = f"""
+        <h1>We can contact via :
+        <ul>
+            <li>{mail}</li>
+            <li>{linkedin}</li>
+        </ul>
+        </h1>
+"""
+    st.markdown(con, unsafe_allow_html=True)
+
+def donate():
+    pass
+
+def get_img_as_base64(file):
+    with open(file, "rb") as f:
+        data = f.read()
+    return base64.b64encode(data).decode()
+
+logo='vqueri.jpeg'
+img = get_img_as_base64(logo)
+
+page_bg_img = f"""
+<style>
+[data-testid="stAppViewContainer"] > .main {{
+# background-image: url("data:image/jpeg;base64,{img}");
+# background-size: auto;
+# # opacity:0.8;
+# background-position: center;
+# background-repeat: no-repeat;
+# background-attachment: local;
+
+}}
+
+[data-testid="stSidebar"] > div:first-child {{
+# background-image: url("data:image/jpeg;base64,{img}");
+background-position: center; 
+background-repeat: no-repeat;
+background-attachment: fixed;
+}}
+
+[data-testid="stHeader"] {{
+margin-top: 0px;
+
+background: rgba(0,0,0,0);
+}}
+
+[data-testid="stToolbar"] {{
+right: 2rem;
+}}
+
+[data-testid="stExpander"]{{
+margin-top:50px
+}}
+
+
+[data-testid="stVerticalBlock"]{{
+margin-top: -5px;
+# margin-top:30px
+}}
+</style>
+"""
+
+html_code = """
+<div style="display: flex;justify-content: center;align-items: center;">
+    <h1 style='text-align: center; color: '#6c757d';'>VideoQuERI, Chatting with Videos made Easy</h1>
+    <img style="width: 150px; margin-right: 10px; border-radius:50px "" src="data:image/jpeg;base64,{}" alt="Image Description">
+</div>
+""".format(img)
+
+

whisper_result.py

@@ -0,0 +1,143 @@
+import time
+import streamlit as st
+from gradio_client import Client
+import yt_dlp
+import pytube
+from pytube.exceptions import VideoUnavailable
+
+client = Client("https://sanchit-gandhi-whisper-jax.hf.space/")
+
+def get_whisper_res_if_the_video_is_youtube_video(video_url, max_recursion_time=20):
+    start_time = time.time()  # Get the start time
+    while True:
+        try:
+                    result = client.predict(
+                            video_url,	# str  in 'YouTube URL' Textbox component
+                            "translate",	# str  in 'Task' Radio component
+                            True,	# bool  in 'Return timestamps' Checkbox component
+                            fn_index=6)
+                    # print('return from fn_index=6')
+                    return result
+        
+        except:
+        
+            try:
+                result = client.predict(
+                                video_url,	# str  in 'YouTube URL' Textbox component
+                                "translate",	# str  in 'Task' Radio component
+                                True,	# bool  in 'Return timestamps' Checkbox component
+                                fn_index=7)
+                # print('return from fn_index=7')
+                return result	
+            
+            except:
+        
+                try:
+                            result = client.predict(
+                        video_url,	# str  in 'YouTube URL' Textbox component
+                        "translate",	# str  in 'Task' Radio component
+                        True,	# bool  in 'Return timestamps' Checkbox component
+                        api_name="/predict_2")
+                            # print('return from /predict_2')
+                            return result
+                except:
+                                if time.time() - start_time > max_recursion_time:
+                                    # result = get_whisper_res_if_the_video_is_not_youtube_video(video_url)
+                                    # return result
+                                    return 
+                                time.sleep(2)
+                                continue
+			
+def get_whisper_res_if_the_video_is_not_youtube_video(video_url, max_recursion_time = 20):
+    start_time = time.time()  # Get the start time
+    while True:
+        try:
+            result = client.predict(
+                    video_url,	# str (filepath or URL to file) in 'inputs' Audio component
+                    "translate",	# str  in 'Task' Radio component
+                    True,	# bool  in 'Return timestamps' Checkbox component
+                    api_name="/predict")
+            return result
+        
+        except:
+            try:
+                result = client.predict(
+                                video_url,	# str  in 'YouTube URL' Textbox component
+                                "translate",	# str  in 'Task' Radio component
+                                True,	# bool  in 'Return timestamps' Checkbox component
+                                api_name="/predict_1")
+                return result
+            
+            except:
+                if time.time() - start_time > max_recursion_time:
+                    result = get_whisper_res_if_the_video_is_youtube_video(video_url)
+                    return result 
+                    
+                time.sleep(2)
+                continue
+
+def postprocess_timestamps(result, index):
+    output_list = []
+    for text in result[index].split('\n'):
+        start = text.split(' -> ')[0][1:]
+        if len(start.split(':')) == 2: #there are only minutes and seconds   
+            min = int(start.split(':')[0])
+            sec = int(float(start.split(':')[1]))
+            
+            index_of_space = text[24:].find(' ')
+            # text = text[24+index_of_space:]
+            text = ':'.join([str(min), str(sec)]) + text[24+index_of_space:]
+
+            output_list.append(text)
+        
+        else: #there are hours also
+            start = text.split(' -> ')[0][1:]
+            
+            hour = int(start.split(':')[0])
+            min = int(start.split(':')[1])
+            sec = int(float(start.split(':')[2]))
+            # text = text[30:]
+
+            text = ':'.join([str(hour),str(min),str(sec)]) + text[30:]
+
+            output_list.append(text)  
+    return output_list  
+
+def postprocess_whisper_jax_output(result):
+    # index = 1 if youtube video, else if non-youtube video
+    try:
+        output_list = postprocess_timestamps(result, index=1)
+    except:
+        output_list = postprocess_timestamps(result, index=0)
+
+    return ', '.join(output_list)
+
+def get_audio_info(url):
+    with yt_dlp.YoutubeDL() as ydl:
+        info = ydl.extract_info(url, download = False)
+
+    return info
+
+def get_whisper_result(video_url):
+    # if the link is youtube video
+    if 'youtube.com/watch?v=' in video_url:
+        try:
+            video = pytube.YouTube(video_url)
+            video.check_availability()
+            
+            result =  get_whisper_res_if_the_video_is_youtube_video(video_url)
+            transcript = postprocess_whisper_jax_output(result)
+            return transcript
+
+        except VideoUnavailable:
+            return False
+        
+    # if the link is not a youtube video
+    else:
+        result =  get_whisper_res_if_the_video_is_not_youtube_video(video_url)
+        if result:
+            transcript = postprocess_whisper_jax_output(result)
+            return transcript
+    
+        return False
+