Update app.py

app.py

@@ -3,76 +3,86 @@ from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingF
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
 from langchain.prompts import PromptTemplate
-from youtube_transcript_api import YouTubeTranscriptApi
 import requests
 import os
 
-# 🔑 Environment variables
+# Environment variables
 api_key = os.getenv("HF_API_KEY")
 RAPIDAPI_KEY = (os.getenv("RAPIDAPI_KEY") or "").strip()
-ytt_api = YouTubeTranscriptApi()
 
-# -----------------------------
-# List Available Languages
-# -----------------------------
-@st.cache_data
-def list_available_languages(video_id):
-    """List available transcript languages using YouTubeTranscriptApi"""
-    languages = []
-    try:
-        transcript_list = ytt_api.list(video_id)  # ✅ use .list()
-        for transcript in transcript_list:        # transcript is an object
-            lang_code = transcript.language_code
-            lang_name = transcript.language
-            is_generated = transcript.is_generated
-            label = f"{lang_name} ({lang_code})" + (" - Auto-generated" if is_generated else "")
-            languages.append((lang_code, label))
-        return languages
-    except Exception as e:
-        st.warning(f"YouTubeTranscriptApi failed to list: {e}")
-        return [("en", "English (en) - Default")]
+if not RAPIDAPI_KEY:
+    st.error("RAPIDAPI_KEY not set")
 
-# -----------------------------
-# Fetch transcripts
-# -----------------------------
+# Check available languages via RapidAPI
 @st.cache_data
-def get_transcript_youtube(video_id, language_code="en"):
-    """Fetch transcript via YouTubeTranscriptApi safely, handling objects/dicts."""
+def get_available_languages(video_id):
+    """Check available transcript languages for a video via RapidAPI"""
+    url = "https://youtube-transcript3.p.rapidapi.com/api/languages"
+    querystring = {"videoId": video_id}
+    headers = {
+        "x-rapidapi-key": RAPIDAPI_KEY,
+        "x-rapidapi-host": "youtube-transcript3.p.rapidapi.com"
+    }
     try:
-        transcripts = ytt_api.list(video_id)  # returns objects
-        transcript_obj = transcripts.find_transcript([language_code])
-        transcript_data = transcript_obj.fetch()  # iterable of dicts or objects
-        transcript = " ".join([t["text"] if isinstance(t, dict) else t.text for t in transcript_data])
-        return transcript
+        response = requests.get(url, headers=headers, params=querystring, timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("success") and "languages" in data:
+                languages = []
+                for lang in data["languages"]:
+                    code = lang.get("code", "")
+                    name = lang.get("name", "")
+                    languages.append((code, f"{name} ({code})"))
+                return languages
+        # Fallback to common languages if API fails
+        return [
+            ("en", "English (en)"),
+            ("hi", "Hindi (hi)"),
+            ("es", "Spanish (es)"),
+            ("fr", "French (fr)"),
+            ("de", "German (de)"),
+            ("ja", "Japanese (ja)"),
+            ("pt", "Portuguese (pt)"),
+            ("ru", "Russian (ru)")
+        ]
     except Exception as e:
-        st.warning(f"YouTubeTranscriptApi failed: {e}")
-        return None
-
+        st.warning(f"Could not fetch languages: {e}. Using common languages.")
+        return [
+            ("en", "English (en)"),
+            ("hi", "Hindi (hi)"),
+            ("es", "Spanish (es)"),
+            ("fr", "French (fr)"),
+            ("de", "German (de)"),
+            ("ja", "Japanese (ja)"),
+            ("pt", "Portuguese (pt)"),
+            ("ru", "Russian (ru)")
+        ]
+
+# Transcript Fetcher
 @st.cache_data
-def get_transcript_rapidapi(video_id, language_code="en"):
-    """Fetch transcript via RapidAPI"""
-    if not RAPIDAPI_KEY:
-        st.warning("RapidAPI key not set")
-        return None
+def get_transcript(video_id, language_code="en"):
+    url = "https://youtube-transcript3.p.rapidapi.com/api/transcript"
+    querystring = {"videoId": video_id, "lang": language_code}
+    headers = {
+        "x-rapidapi-key": RAPIDAPI_KEY,
+        "x-rapidapi-host": "youtube-transcript3.p.rapidapi.com"
+    }
     try:
-        url = "https://youtube-transcript3.p.rapidapi.com/"
-        querystring = {"videoId": video_id, "lang": language_code}  # ✅ correct param
-        headers = {
-            "x-rapidapi-key": RAPIDAPI_KEY,
-            "x-rapidapi-host": "youtube-transcript3.p.rapidapi.com"
-        }
-        response = requests.get(url, headers=headers, params=querystring, timeout=20)
-        response.raise_for_status()
+        response = requests.get(url, headers=headers, params=querystring, timeout=10)
+        if response.status_code != 200:
+            st.error(f"API Error: {response.status_code}")
+            return None
         data = response.json()
-        transcript = " ".join([item.get("text", "") for item in data.get("transcript", [])])
-        return transcript if transcript else None
+        if data.get("success") and "transcript" in data:
+            return ' '.join([item.get('text', '') for item in data["transcript"]])
+        else:
+            st.warning("Unexpected API response format")
+            return None
     except Exception as e:
-        st.error(f"RapidAPI transcript fetch failed: {e}")
+        st.error(f"Error: {str(e)}")
         return None
 
-# -----------------------------
 # Vector Store
-# -----------------------------
 @st.cache_data
 def create_vector_store(transcript):
     splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
@@ -83,9 +93,7 @@ def create_vector_store(transcript):
     )
     return FAISS.from_documents(docs, embeddings)
 
-# -----------------------------
 # Build Model
-# -----------------------------
 def build_model(model_choice, temperature=0.7):
     if model_choice == "Flan-T5 (Free)":
         llm = HuggingFaceEndpoint(
@@ -112,9 +120,7 @@ def build_model(model_choice, temperature=0.7):
         )
         return ChatHuggingFace(llm=llm, temperature=temperature)
 
-# -----------------------------
 # Prompt Template
-# -----------------------------
 prompt_template = PromptTemplate(
     template=(
         "Answer the question based on the context below.\n\n"
@@ -125,72 +131,51 @@ prompt_template = PromptTemplate(
     input_variables=["context", "question"]
 )
 
-# -----------------------------
-# Streamlit UI
-# -----------------------------
-st.title("🎥 YouTube Transcript Chatbot")
+# UI
+st.title("YouTube Transcript Chatbot")
 
-video_id = st.text_input("🎬 YouTube Video ID", value="lv1_-RER4_I")
-query = st.text_area("💬 Your Query", value="What is RAG?")
-model_choice = st.radio("🧠 Model to Use", ["Flan-T5 (Free)", "DeepSeek", "OpenAI"])
-temperature = st.slider("🔥 Temperature", 0, 100, value=50) / 100.0
+video_id = st.text_input("YouTube Video ID", value="lv1_-RER4_I")
+query = st.text_area("Your Query", value="What is RAG?")
+model_choice = st.radio("Model to Use", ["Flan-T5 (Free)", "DeepSeek", "OpenAI"])
+temperature = st.slider("Temperature", 0, 100, value=50) / 100.0
 
-source_choice = st.radio(
-    "📜 Transcript Source",
-    ["Auto (RapidAPI → YouTubeTranscriptApi)", "RapidAPI", "YouTubeTranscriptApi"]
-)
-
-# Select language
+# Get available languages for this video
 language_code = None
 if video_id:
-    with st.spinner("🔎 Checking available transcript languages..."):
-        available_langs = list_available_languages(video_id)
-    if available_langs:
-        st.success(f"Found {len(available_langs)} transcript(s)")
-        lang_options = {label: code for code, label in available_langs}
-        selected_label = st.selectbox("🌐 Select Transcript Language", options=list(lang_options.keys()))
+    with st.spinner("Checking available languages..."):
+        available_languages = get_available_languages(video_id)
+    
+    if available_languages:
+        st.success(f"Found {len(available_languages)} language(s)")
+        lang_options = {label: code for code, label in available_languages}
+        selected_label = st.selectbox("Select Language", options=list(lang_options.keys()))
         language_code = lang_options[selected_label]
     else:
-        st.warning("No transcripts found for this video.")
+        st.warning("No languages found")
 
-# Fetch transcript & answer
-if st.button("🚀 Run Chatbot"):
+if st.button("Run Chatbot"):
     if not video_id or not query or not language_code:
-        st.warning("Please provide video ID, query, and select a language.")
+        st.warning("Please fill in all fields and select a language.")
     else:
-        with st.spinner("🧾 Fetching transcript..."):
-            transcript = None
-            if source_choice == "RapidAPI":
-                transcript = get_transcript_rapidapi(video_id, language_code)
-            elif source_choice == "YouTubeTranscriptApi":
-                transcript = get_transcript_youtube(video_id, language_code)
-            else:  # Auto mode
-                transcript = get_transcript_rapidapi(video_id, language_code)
-                if not transcript:
-                    transcript = get_transcript_youtube(video_id, language_code)
-
+        with st.spinner("Fetching transcript..."):
+            transcript = get_transcript(video_id, language_code)
+            
             if not transcript:
-                st.error("❌ Could not fetch transcript from any source.")
+                st.error("Could not fetch transcript.")
             else:
-                st.success(f"✅ Transcript fetched ({len(transcript)} characters).")
-
-                with st.spinner("⚙️ Generating response..."):
-                    retriever = create_vector_store(transcript).as_retriever(search_type="mmr", search_kwargs={"k": 5})
+                st.success(f"Transcript fetched ({len(transcript)} characters).")
+                
+                with st.spinner("Generating response..."):
+                    retriever = create_vector_store(transcript).as_retriever(
+                        search_type="mmr",
+                        search_kwargs={"k": 5}
+                    )
                     relevant_docs = retriever.invoke(query)
                     context_text = "\n\n".join(doc.page_content for doc in relevant_docs)
                     prompt = prompt_template.format(context=context_text, question=query)
-
+                    
                     model = build_model(model_choice, temperature)
                     response = model.invoke(prompt)
                     response_text = response.content if hasattr(response, 'content') else str(response)
-                    st.text_area("🧩 Model Response", value=response_text, height=400)
-
-# Sidebar
-with st.sidebar:
-    st.header("ℹ️ About this App")
-    st.write("""
-    - Uses both **RapidAPI** and **YouTubeTranscriptApi**  
-    - Correctly detects transcript languages dynamically  
-    - RAG-based Q&A powered by Hugging Face models  
-    - Models supported: Flan-T5 (Free), DeepSeek, OpenAI (via HF)
-    """)
+                    
+                    st.text_area("Response", value=response_text, height=400)