Update app.py

app.py

@@ -12,51 +12,60 @@ load_dotenv()
 client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
 def transcribe_audio(audio_file):
-    """Transcribe audio using Whisper API"""
+    """Transcribe audio using Whisper API with timestamps"""
     try:
         with open(audio_file, "rb") as audio:
             transcript = client.audio.transcriptions.create(
                 model="whisper-1",
                 file=audio,
-                response_format="verbose_json"
+                response_format="verbose_json",
+                timestamp_granularities=["segment"]
             )
         return transcript
     except Exception as e:
         st.error(f"Error in transcription: {str(e)}")
         return None
 
-def analyze_content(transcript, lesson_plan):
-    """Analyze transcript using GPT-4 to generate structured notes"""
+def format_timestamp(seconds):
+    """Convert seconds to HH:MM:SS format"""
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    seconds = int(seconds % 60)
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+def generate_lesson_plan(transcript):
+    """Generate a structured lesson plan from the transcript"""
     try:
-        system_prompt = """You are an expert educational content analyzer. 
-        Your task is to:
-        1. Analyze the lecture transcript
-        2. Structure the content according to the lesson plan
-        3. Identify key topics and subtopics
-        4. Create timestamps for important points
-        5. Generate a comprehensive summary
-        Format the output in markdown with clear sections."""
+        system_prompt = """You are an educational content expert. Generate a detailed lesson plan from the lecture transcript. 
+        The lesson plan should include:
+        1. Main Topics
+        2. Subtopics
+        3. Key Learning Objectives
+        4. Important Concepts
+        Format the output in markdown with clear hierarchical structure."""
 
         response = client.chat.completions.create(
             model="gpt-4-turbo-preview",
             messages=[
                 {"role": "system", "content": system_prompt},
-                {"role": "user", "content": f"Lesson Plan:\n{lesson_plan}\n\nTranscript:\n{transcript}"}
+                {"role": "user", "content": f"Generate a lesson plan from this transcript:\n{transcript}"}
             ],
             temperature=0.3,
-            max_tokens=4000
+            max_tokens=2000
         )
         
         return response.choices[0].message.content
     except Exception as e:
-        st.error(f"Error in analysis: {str(e)}")
+        st.error(f"Error generating lesson plan: {str(e)}")
         return None
 
-def save_notes(notes, filename):
-    """Save generated notes to a file"""
-    with open(filename, 'w', encoding='utf-8') as f:
-        f.write(notes)
-    return filename
+def format_transcript_with_timestamps(transcript_data):
+    """Format transcript with timestamps in a readable format"""
+    formatted_text = "# Lecture Transcript with Timestamps\n\n"
+    for segment in transcript_data.segments:
+        start_time = format_timestamp(segment.start)
+        formatted_text += f"**[{start_time}]** {segment.text}\n\n"
+    return formatted_text
 
 # Streamlit UI
 def main():
@@ -64,65 +73,76 @@ def main():
     
     st.title("🎓 Lecture Notes Generator")
     
-    # Sidebar for lesson plan
-    st.sidebar.header("Lesson Plan")
-    lesson_plan = st.sidebar.text_area(
-        "Enter the lesson plan or topics to be covered:",
-        height=300
-    )
-    
-    # Main content area
-    col1, col2 = st.columns([1, 1])
+    # Create two columns with custom widths
+    col1, col2 = st.columns([1, 3])
     
+    # Left column for upload (smaller)
     with col1:
-        st.header("Upload Lecture Recording")
+        st.header("Upload Recording")
         uploaded_file = st.file_uploader("Choose an audio file", type=['mp3', 'wav', 'm4a'])
         
         if uploaded_file:
             st.audio(uploaded_file)
             
-            if st.button("Generate Notes"):
-                if not lesson_plan:
-                    st.warning("Please enter a lesson plan first.")
-                    return
-                
-                with st.spinner("Processing audio..."):
-                    # Save uploaded file temporarily
-                    temp_path = f"temp_audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-                    with open(temp_path, "wb") as f:
-                        f.write(uploaded_file.getvalue())
+            if st.button("Generate Notes", type="primary", use_container_width=True):
+                # Create tabs in the right column for different outputs
+                with col2:
+                    tab1, tab2 = st.tabs(["📝 Transcript", "📋 Lesson Plan"])
                     
-                    # Transcribe audio
-                    transcript = transcribe_audio(temp_path)
-                    if transcript:
-                        st.success("Transcription completed!")
+                    with st.spinner("Processing audio..."):
+                        # Save uploaded file temporarily
+                        temp_path = f"temp_audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+                        with open(temp_path, "wb") as f:
+                            f.write(uploaded_file.getvalue())
                         
-                        # Analyze content
-                        with st.spinner("Generating structured notes..."):
-                            notes = analyze_content(transcript.text, lesson_plan)
-                            if notes:
-                                # Save notes
-                                filename = f"lecture_notes_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
-                                save_notes(notes, filename)
-                                
-                                # Display notes
-                                with col2:
-                                    st.header("Generated Notes")
-                                    st.markdown(notes)
-                                    
-                                    # Download button
-                                    with open(filename, 'r', encoding='utf-8') as f:
-                                        st.download_button(
-                                            label="Download Notes",
-                                            data=f.read(),
-                                            file_name=filename,
-                                            mime="text/markdown"
-                                        )
-                    
-                    # Cleanup
-                    os.remove(temp_path)
-                    if os.path.exists(filename):
-                        os.remove(filename)
+                        # Transcribe audio
+                        transcript_data = transcribe_audio(temp_path)
+                        if transcript_data:
+                            # Format transcript with timestamps
+                            formatted_transcript = format_transcript_with_timestamps(transcript_data)
+                            
+                            # Generate lesson plan
+                            lesson_plan = generate_lesson_plan(transcript_data.text)
+                            
+                            # Display transcript in first tab
+                            with tab1:
+                                st.markdown(formatted_transcript)
+                                # Download button for transcript
+                                st.download_button(
+                                    label="Download Transcript",
+                                    data=formatted_transcript,
+                                    file_name=f"transcript_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md",
+                                    mime="text/markdown"
+                                )
+                            
+                            # Display lesson plan in second tab
+                            with tab2:
+                                if lesson_plan:
+                                    st.markdown(lesson_plan)
+                                    # Download button for lesson plan
+                                    st.download_button(
+                                        label="Download Lesson Plan",
+                                        data=lesson_plan,
+                                        file_name=f"lesson_plan_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md",
+                                        mime="text/markdown"
+                                    )
+                        
+                        # Cleanup
+                        os.remove(temp_path)
+    
+    # Right column instructions when no file is uploaded
+    if not uploaded_file:
+        with col2:
+            st.info("""
+            👈 Start by uploading an audio file on the left side.
+            
+            The system will automatically:
+            1. Transcribe the lecture with timestamps
+            2. Generate a structured lesson plan
+            3. Provide downloadable versions of both
+            
+            Supported formats: MP3, WAV, M4A
+            """)
 
 if __name__ == "__main__":
-    main()
+    main()