fix youtube video issue and some minor fixes

app.py

@@ -1,4 +1,5 @@
 import re
+from pymongo import MongoClient
 import streamlit as st
 from datetime import datetime, date, time, timedelta
 from pathlib import Path
@@ -334,6 +335,63 @@ def create_session_form(course_id):
     # else:
 
 
+load_dotenv()
+MONGO_URI = os.getenv('MONGO_URI')
+client = MongoClient(MONGO_URI)
+db = client["novascholar_db"]
+subjective_tests_collection = db["subjective_tests"]
+resources_collection = db['resources']
+quizzes_collection = db['quizzes']
+chat_history_collection = db['chat_history']
+polls_collection = db['polls']
+
+
+
+def delete_session(course_id: str, session_id: str) -> bool:
+    """Delete a session and all its associated data"""
+    try:
+        # Delete all resources for this session
+        resources_collection.delete_many({
+            "course_id": course_id,
+            "session_id": session_id
+        })
+        
+        # Delete all quizzes for this session
+        quizzes_collection.delete_many({
+            "course_id": course_id,
+            "session_id": session_id
+        })
+        
+        # Delete all subjective tests
+        subjective_tests_collection.delete_many({
+            "course_id": course_id,
+            "session_id": session_id
+        })
+        
+        # Delete chat history
+        chat_history_collection.delete_many({
+            "course_id": course_id,
+            "session_id": session_id
+        })
+        
+        # Delete session polls
+        polls_collection.delete_many({
+            "course_id": course_id,
+            "session_id": session_id
+        })
+
+        # Finally remove session from course
+        result = courses_collection.update_one(
+            {"course_id": course_id},
+            {"$pull": {"sessions": {"session_id": session_id}}}
+        )
+        
+        return result.modified_count > 0
+
+    except Exception as e:
+        print(f"Error deleting session: {e}")
+        return False
+
 def get_new_student_id():
     """Generate a new student ID by incrementing the last student ID"""
     last_student = students_collection.find_one(sort=[("SID", -1)])
@@ -1372,6 +1430,10 @@ def main_dashboard():
                         use_container_width=True,
                     ):
                         st.session_state.show_create_session_form = True
+                    
+                    if st.button("Delete a Session", key="delete_session", use_container_width=True):
+                        # session_id = st.text_input("Enter the Session ID to delete")
+                        st.session_state.show_delete_session_form = True
 
             if st.button("Logout", use_container_width=True):
                 for key in st.session_state.keys():
@@ -1386,6 +1448,14 @@ def main_dashboard():
             create_session_form(selected_course_id)
         elif st.session_state.get("show_enroll_course_page"):
             show_available_courses(st.session_state.username, st.session_state.user_type, st.session_state.user_id)
+        elif st.session_state.get("show_delete_session_form"):
+            session_options = [f"{session['title']} (ID: {session['session_id']})" for session in sessions]
+            session_id = st.selectbox("Select Session to Delete", session_options)
+            session_id = session_id.split(" (ID: ")[-1][:-1]
+            if st.button("Delete Session"):
+                if delete_session(selected_course_id, session_id):
+                    st.success(f"Session {session_id} deleted successfully!")
+                    st.rerun()
         else:
             # Main content
             if "selected_session" in st.session_state:

live_chat_feature.py

@@ -20,7 +20,7 @@ model = genai.GenerativeModel("gemini-1.5-flash")
 def display_live_chat_interface(session, user_id, course_id):
     """Main interface for live chat sessions - handles both faculty and student views"""
     st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
-    st.markdown("#### Live Class Chat Session")
+    st.markdown("#### In-class Chatbot Session")
     
     # Initialize session states
     if 'chat_active' not in st.session_state:
@@ -229,14 +229,14 @@ def display_faculty_controls(session, faculty_id, course_id):
     
     # Show scheduled sessions
     st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
-    st.markdown("##### 📅 Scheduled Chat Sessions")
+    st.markdown("##### 📅 Scheduled Chatbot Sessions")
     scheduled_sessions = list(live_chat_sessions_collection.find({
         "session_id": session['session_id'],
         "status": "scheduled"
     }))
 
     # Schedule new session
-    with st.expander("➕ Schedule New Chat Session"):
+    with st.expander("➕ Schedule New Chatbot Session"):
         col1, col2, col3 = st.columns([2, 2, 1])
         with col1:
             session_date = st.date_input("📅 Date", min_value=datetime.now().date())
@@ -279,7 +279,7 @@ def display_faculty_controls(session, faculty_id, course_id):
     # Start immediate session
     if not st.session_state.get('chat_active', False):
         st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
-        st.markdown("##### 🎯 Start Immediate Session")
+        st.markdown("##### 🎯 Start an Immediate Session")
         col1, col2 = st.columns([3, 1])
         with col1:
             immediate_duration = st.selectbox(

session_page.py

@@ -5,6 +5,7 @@ import requests
 import streamlit as st
 from datetime import datetime, timedelta
 from youtube_transcript_api import YouTubeTranscriptApi
+# from process_yt_videos import process_youtube_video
 from session_page_alt import display_pre_test_results, pre_generate_questions, pre_save_subjective_test, submit_pre_subjective_test
 from utils.helpers import display_progress_bar, create_notification, format_datetime
 from file_upload_vectorize import upload_resource, extract_text_from_file, create_vector_store, resources_collection, model, assignment_submit
@@ -1139,7 +1140,7 @@ def fetch_youtube_video_title(video_url):
             st.write("Please try again or choose a different video.")
         return None
 
-def upload_video_source(course_id, session_id, video_url):
+def upload_video_source(course_id, session_id, video_url, video_transcript):
     """
     Upload video source and its transcript with comprehensive error handling
     """
@@ -1151,6 +1152,7 @@ def upload_video_source(course_id, session_id, video_url):
     # Display processing message
     # with st.spinner("Processing your YouTube video..."):
         # Validate video URL
+    
     video_id = extract_youtube_id(video_url)
     if not video_id:
         return None
@@ -1161,10 +1163,16 @@ def upload_video_source(course_id, session_id, video_url):
         return None
         
     # Extract transcript
-    transcript = extract_youtube_transcript(video_url)
-    if not transcript:
-        return None
-    
+    # transcript = extract_youtube_transcript(video_url)
+    # if not transcript:
+    #     return None
+    # transcript_data = extract_youtube_transcript2(video_url)
+    # if not transcript_data:
+    #     return None
+    # print(transcript_data)
+    # transcript = transcript_data['full_text']
+    # print(transcript)
+
     # Create resource document
     resource_data = {
         "_id": ObjectId(),
@@ -1172,7 +1180,7 @@ def upload_video_source(course_id, session_id, video_url):
         "session_id": session_id,
         "file_name": video_title,
         "file_type": "video",
-        "text_content": transcript,
+        "text_content": video_transcript,
         "material_type": "video",
         "source_url": video_url,
         "uploaded_at": datetime.utcnow(),
@@ -1229,7 +1237,7 @@ def upload_video_source(course_id, session_id, video_url):
         # Create vector store for the transcript
         # create_vector_store(transcript, resource_id)
         # Create vector store for the transcript
-        vector_store_result = create_vector_store(transcript, resource_id)
+        vector_store_result = create_vector_store(video_transcript, resource_id)
         if not vector_store_result:
             st.error("⚠️ Failed to create vector store for the transcript.")
             # Rollback insertions
@@ -1258,14 +1266,83 @@ def upload_video_source(course_id, session_id, video_url):
         3. Contact support if the issue persists
         """)
         return None
+    
+
+# def upload_video_source(course_id: str, session_id: str, video_url: str):
+#     """Upload video source with transcript."""
+#     if not video_url:
+#         st.error("Please provide a YouTube URL")
+#         return None
+        
+#     with st.spinner("Processing video..."):
+#         resource_data = process_youtube_video(video_url, course_id, session_id)
+        
+#         if resource_data:
+#             try:
+#                 # Insert into your database
+#                 result = resources_collection.insert_one(resource_data)
+                
+#                 # Update course document
+#                 courses_collection.update_one(
+#                     {
+#                         "course_id": course_id,
+#                         "sessions.session_id": session_id
+#                     },
+#                     {
+#                         "$push": {"sessions.$.pre_class.resources": result.inserted_id}
+#                     }
+#                 )
+                
+#                 st.success(f"✅ Successfully added: {resource_data['file_name']}")
+#                 return result.inserted_id
+                
+#             except Exception as e:
+#                 st.error(f"Error saving to database: {str(e)}")
+#                 return None
+        
+#         return None
+# def upload_video_source(course_id: str, session_id: str, video_url: str, video_transcript: str):
+#     """Upload video source with transcript."""
+#     if not video_url:
+#         st.error("Please provide a YouTube URL")
+#         return None
+        
+#     with st.spinner("Processing video..."):
+#         # resource_data = process_youtube_video(video_url, course_id, session_id)
+#         # if resource_data:
+#         try:
+#             # Insert into your database
+#             result = resources_collection.insert_one(resource_data)
+            
+#             # Update course document
+#             courses_collection.update_one(
+#                 {
+#                     "course_id": course_id,
+#                     "sessions.session_id": session_id
+#                 },
+#                 {
+#                     "$push": {"sessions.$.pre_class.resources": result.inserted_id}
+#                 }
+#             )
+            
+#             st.success(f"✅ Successfully added: {resource_data['file_name']}")
+#             return result.inserted_id
+            
+#         except Exception as e:
+#             st.error(f"Error saving to database: {str(e)}")
+#             return None
+        
+        # return None
 
-def upload_preclass_materials(session_id, course_id, student_id):
+def upload_preclass_materials(session, session_id, course_id, student_id):
     """Upload pre-class materials and manage external resources for a session"""
     st.subheader("Pre-class Materials Management")
     
     # Create tabs for different functionalities
-    upload_tab, videos_tab, web_resources ,external_tab, pre_class_tab, pre_class_evaluate, pre_class_quiz = st.tabs(["Upload Materials","Upload Video Sources","Web Resources", "Resources by Perplexity", "Pre-class Questions", "Pre-class Evaluation", "Pre-class Quiz"])
+    # upload_tab, videos_tab, web_resources, pre_class_tab, pre_class_evaluate, pre_class_quiz = st.tabs(["Upload Materials","Upload Video Sources","Web Resources", "Pre-class Questions", "Pre-class Evaluation", "Pre-class Quiz"])
     
+    pre_class_quiz, pre_class_tab, pre_class_evaluate, upload_tab, videos_tab, web_resources = st.tabs(["Pre-class Quiz", "Pre-class Subjective Questions", "Subjective Questions Evaluation", "Upload Materials", "Upload Video Sources", "Web Resources"])
+
     with upload_tab:
         # Original file upload functionality
         uploaded_file = st.file_uploader("Upload Material", type=['txt', 'pdf', 'docx'])
@@ -1298,12 +1375,52 @@ def upload_preclass_materials(session_id, course_id, student_id):
     with videos_tab:
         # Upload video sources
         st.info("Upload video sources for this session.")
-        video_url = st.text_input("Enter a Youtube Video URL")
+        
+        # Add URL input and transcript guide
+        col1, col2 = st.columns([1,1])
+        
+        with col1:
+            video_url = st.text_input("Enter a YouTube Video URL")
+            
+        with col2:
+            st.markdown("##### How to Get Video Transcript")
+            st.markdown("""
+            1. Visit [tactiq.io Transcript Tool](https://tactiq.io/tools/youtube-transcript)
+            2. In the input field, paste your YouTube video URL
+            3. Click on "Get Video Transcript" button
+            4. When transcript appears, click "Copy" button
+            5. Return here and paste the transcript below
+            """)
+        
+        # Add transcript input with clear instructions
+        st.markdown("##### Paste Video Transcript")
+        st.info("For the chatbot context, please provide the video transcript")
+        video_transcript = st.text_area(
+            "Video Transcript", 
+            height=200,
+            placeholder="Paste the copied transcript from tactiq.io here..."
+        )
+        
+        # Add upload button
         if st.button("Upload Video"):
-            with st.spinner("Processing video source..."):
-                video_resource_id = upload_video_source(course_id, session_id, video_url)
+            if not video_url:
+                st.error("Please provide a YouTube video URL")
+            else:
+                with st.spinner("Processing video source..."):
+                    video_resource_id = upload_video_source(course_id, session_id, video_url, video_transcript)
+    
+    # with videos_tab:
+    #     # Upload video sources
+    #     st.info("Upload video sources for this session.")
+    #     video_url = st.text_input("Enter a Youtube Video URL")
+    #     video_transcript = st.text_area("Please paste the Youtube Video Transcript", height=200)
+    #     if st.button("Upload Video"):
+    #         with st.spinner("Processing video source..."):
+    #             video_resource_id = upload_video_source(course_id, session_id, video_url)
                 # if video_resource_id:
                 #     st.success("Video source uploaded successfully!")
+
+
     
     with web_resources:
         st.markdown("##### Upload Web Resource Links")
@@ -1324,8 +1441,8 @@ def upload_preclass_materials(session_id, course_id, student_id):
                 placeholder="https://colab.research.google.com/... or other web resource")
             resource_type = st.selectbox("Resource Type", 
                 ["Jupyter Notebook", "Presentation", "Documentation", "Tutorial", "Other"])
-            resource_description = st.text_area("Description (Optional)", 
-                placeholder="Brief description of the resource")
+            text_content = st.text_area("Text Content (for Chatbot)", 
+                placeholder="Brief text content for the resource")
             
             submit_resource = st.form_submit_button("Add Resource")
 
@@ -1343,12 +1460,13 @@ def upload_preclass_materials(session_id, course_id, student_id):
                             "file_type": "web_resource",
                             "material_type": resource_type,
                             "source_url": resource_url,
-                            "description": resource_description,
+                            "text_content": text_content,
                             "uploaded_at": datetime.utcnow()
                         }
                         
                         # Check if resource already exists
                         existing_resource = resources_collection.find_one({
+                            "course_id": course_id,
                             "session_id": session_id,
                             "source_url": resource_url
                         })
@@ -1374,67 +1492,65 @@ def upload_preclass_materials(session_id, course_id, student_id):
                     except Exception as e:
                         st.error(f"Error adding resource: {str(e)}")
         
-
-
-    with external_tab:
-        # Fetch and display external resources
-        session_data = courses_collection.find_one(
-            {"course_id": course_id, "sessions.session_id": session_id},
-            {"sessions.$": 1}
-        )
+    # with external_tab:
+    #     # Fetch and display external resources
+    #     session_data = courses_collection.find_one(
+    #         {"course_id": course_id, "sessions.session_id": session_id},
+    #         {"sessions.$": 1}
+    #     )
         
-        if session_data and session_data.get('sessions'):
-            session = session_data['sessions'][0]
-            external = session.get('external_resources', {})
+    #     if session_data and session_data.get('sessions'):
+    #         session = session_data['sessions'][0]
+    #         external = session.get('external_resources', {})
             
-            # Display web articles
-            if 'readings' in external:
-                st.subheader("Web Articles and Videos")
-                for reading in external['readings']:
-                    col1, col2 = st.columns([3, 1])
-                    with col1:
-                        st.markdown(f"**{reading['title']}**")
-                        st.markdown(f"Type: {reading['type']} | Est. time: {reading['estimated_read_time']}")
-                        st.markdown(f"URL: [{reading['url']}]({reading['url']})")
-                    with col2:
-                        if st.button("Extract Content", key=f"extract_{reading['url']}"):
-                            with st.spinner("Extracting content..."):
-                                content = extract_external_content(reading['url'], reading['type'])
-                                if content:
-                                    resource_id = upload_external_resource(
-                                        course_id,
-                                        session_id,
-                                        reading['title'],
-                                        content,
-                                        reading['type'].lower(),
-                                        reading['url']
-                                    )
-                                    st.success("Content extracted and stored successfully!")
+    #         # Display web articles
+    #         if 'readings' in external:
+    #             st.subheader("Web Articles and Videos")
+    #             for reading in external['readings']:
+    #                 col1, col2 = st.columns([3, 1])
+    #                 with col1:
+    #                     st.markdown(f"**{reading['title']}**")
+    #                     st.markdown(f"Type: {reading['type']} | Est. time: {reading['estimated_read_time']}")
+    #                     st.markdown(f"URL: [{reading['url']}]({reading['url']})")
+    #                 with col2:
+    #                     if st.button("Extract Content", key=f"extract_{reading['url']}"):
+    #                         with st.spinner("Extracting content..."):
+    #                             content = extract_external_content(reading['url'], reading['type'])
+    #                             if content:
+    #                                 resource_id = upload_external_resource(
+    #                                     course_id,
+    #                                     session_id,
+    #                                     reading['title'],
+    #                                     content,
+    #                                     reading['type'].lower(),
+    #                                     reading['url']
+    #                                 )
+    #                                 st.success("Content extracted and stored successfully!")
             
-            # Display books
-            if 'books' in external:
-                st.subheader("Recommended Books")
-                for book in external['books']:
-                    st.markdown(f"""
-                    **{book['title']}** by {book['author']}
-                    - ISBN: {book['isbn']}
-                    - Chapters: {book['chapters']}
-                    """)
+    #         # Display books
+    #         if 'books' in external:
+    #             st.subheader("Recommended Books")
+    #             for book in external['books']:
+    #                 st.markdown(f"""
+    #                 **{book['title']}** by {book['author']}
+    #                 - ISBN: {book['isbn']}
+    #                 - Chapters: {book['chapters']}
+    #                 """)
             
-            # Display additional resources
-            if 'additional_resources' in external:
-                st.subheader("Additional Resources")
-                for resource in external['additional_resources']:
-                    st.markdown(f"""
-                    **{resource['title']}** ({resource['type']})
-                    - {resource['description']}
-                    - URL: [{resource['url']}]({resource['url']})
-                    """)
+    #         # Display additional resources
+    #         if 'additional_resources' in external:
+    #             st.subheader("Additional Resources")
+    #             for resource in external['additional_resources']:
+    #                 st.markdown(f"""
+    #                 **{resource['title']}** ({resource['type']})
+    #                 - {resource['description']}
+    #                 - URL: [{resource['url']}]({resource['url']})
+    #                 """)
 
     with pre_class_tab:
         if st.session_state.user_type == "faculty":
             faculty_id = st.session_state.user_id
-            st.subheader("Create Pre class Subjective Test")
+            st.markdown("#### Create Pre-class Subjective Questions")
 
             # Create a form for test generation
             with st.form("pre_create_subjective_test_form"):
@@ -2172,8 +2288,8 @@ def display_session_outline(session, outline, course_id):
     #         st.markdown("**Materials Needed:**")
     #         for material in activity["materials_needed"]:
     #             st.markdown(f"- {material}")
-    st.markdown("#### 📋 Session Outline")
-    with st.expander("View Session Outline"):
+    st.markdown("#### 📋 Teaching Strategy")
+    with st.expander("View Teaching Strategy"):
         # Opening Activities Section
         # st.markdown('<div class="session-section">', unsafe_allow_html=True)
         st.markdown("<div style='margin-top: 10px;'></div>", unsafe_allow_html=True)
@@ -2310,7 +2426,7 @@ def display_in_class_content(session, user_type, course_id, user_id):
                 # st.write("Found existing session outline")
                 st.session_state.session_outline = stored_outline
             else:
-                st.write("No existing session outline found")
+                print("No existing session outline found")
                 st.session_state.session_outline = None
         
     except Exception as e:
@@ -2320,9 +2436,9 @@ def display_in_class_content(session, user_type, course_id, user_id):
     if user_type == 'faculty':
         # st.markdown("<div style='margin-top: 10px;'></div>", unsafe_allow_html=True)
         if not st.session_state.session_outline: 
-            st.markdown("#### Session Outline")
-            if st.button("Generate a Session Outline"):
-                with st.spinner("Generating session outline..."):
+            st.markdown("#### 📋 Teaching Strategy")
+            if st.button("Generate a Teaching Strategy"):
+                with st.spinner("Generating the Teaching Strategy..."):
                     outline = generate_session_outline(session['session_id'], course_id)
                     if outline:
                         display_session_outline(session, outline, course_id)
@@ -3038,15 +3154,15 @@ def get_response_from_llm(raw_data):
         return None
 
 import typing_extensions as typing 
-from typing import Union, List, Dict
+from typing import Optional, Union, List, Dict
 
 # class Topics(typing.TypedDict):
 #     overarching_theme: List[Dict[str, Union[str, List[Dict[str, Union[str, List[str]]]]]]]
 #     indirect_topics: List[Dict[str, str]]
 
-def extract_topics_from_materials(session):
+def extract_topics_from_materials(course_id, session):
     """Extract topics from pre-class materials"""
-    materials = resources_collection.find({"session_id": session['session_id']})
+    materials = resources_collection.find({"session_id": session['session_id'], "course_id": course_id})
     texts = ""
     if materials:
         for material in materials:
@@ -3224,7 +3340,7 @@ def get_preclass_analytics(session, course_id):
     print("Total chat histories collected:", len(all_chat_histories))
 
     # Extract topics with debug print
-    topics = extract_topics_from_materials(session)
+    topics = extract_topics_from_materials(course_id, session)
     # Debug print 5: Check topics
     print("Extracted topics:", topics)
     
@@ -3914,7 +4030,7 @@ def display_session_content(student_id, course_id, session, username, user_type)
             "Evaluate Subjective Tests"
         ])
         with tabs[0]:
-            upload_preclass_materials(session['session_id'], course_id, student_id)
+            upload_preclass_materials(session, session['session_id'], course_id, student_id)
         with tabs[1]:
             display_in_class_content(session, user_type, course_id, user_type)
         with tabs[2]:

subjective_test_evaluation.py

@@ -659,7 +659,7 @@ def pre_display_evaluation_to_faculty(session_id, student_id, course_id):
     """
     Display interface for faculty to generate and view evaluations
     """
-    st.header("Evaluate Pre Subjective Tests")
+    st.markdown("#### Evaluate Pre-class Subjective Questions")
 
     try:
         # Fetch available tests