Update app.py

app.py

@@ -1,138 +1,31 @@
-import os
-import ffmpeg
-import whisper
-import streamlit as st
-from groq import Groq
-
-# Set the app title and description with styling
-st.set_page_config(page_title="Audio/Video Transcription & Summarization", page_icon="🎙️")
-st.title("🎙️ Audio/Video Transcription & Summarization")
-st.write("Easily upload an audio or video file to get a transcription and a quick summary.")
-
-# Add a sidebar for settings and instructions
-with st.sidebar:
-    st.header("Settings")
-    st.write("Configure app preferences here.")
-    enable_summary = st.checkbox("Enable Summarization", value=True)
-    st.info("Note: Summarization uses the Groq API.")
-
-# Retrieve the API key from environment variables or Streamlit secrets
-GROQ_API_KEY = os.getenv("GROQ_API_KEY") or st.secrets["GROQ_API_KEY"]
-os.environ["GROQ_API_KEY"] = GROQ_API_KEY
-
-# Create a temporary directory
-temp_dir = "temp"
-os.makedirs(temp_dir, exist_ok=True)
-
-# Display file uploader with improved layout and style
-st.subheader("Upload Audio/Video File")
-uploaded_file = st.file_uploader("Choose an audio or video file...", type=["mp4", "mov", "avi", "mkv", "wav", "mp3"])
-
-# Function to extract audio from video
-def extract_audio(video_path, audio_path="temp/temp_audio.wav"):
-    """Extracts audio from video."""
-    try:
-        # Run ffmpeg command with stderr capture for better error handling
-        ffmpeg.input(video_path).output(audio_path).run(overwrite_output=True, capture_stdout=True, capture_stderr=True)
-    except ffmpeg.Error as e:
-        st.error("Error processing file with FFmpeg: " + e.stderr.decode())
-    return audio_path
-
-# Function to transcribe audio using Whisper model
-def transcribe_audio(audio_path):
-    """Transcribes audio to text using Whisper model."""
-    model = whisper.load_model("base")
-    result = model.transcribe(audio_path)
-    return result["text"]
-
-# Function to summarize text using Groq API
-def summarize_text(text):
-    """Summarizes text using Groq API."""
-    client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
-    response = client.chat.completions.create(
-        messages=[{"role": "user", "content": f"Summarize the following text: {text}"}],
-        model="llama3-8b-8192"
-    )
-    summary = response.choices[0].message.content
-    return summary
-
-# Main processing function with progress indicators
-def process_media(media_file):
-    """Processes audio or video: extracts audio, transcribes it, and summarizes the transcription if enabled."""
-    # Save the uploaded file to a temporary path
-    temp_file_path = os.path.join(temp_dir, media_file.name)
-    with open(temp_file_path, "wb") as f:
-        f.write(media_file.getbuffer())
-
-    # Determine if the file is a video or audio
-    if media_file.name.endswith(('.mp4', '.mov', '.avi', '.mkv')):
-        st.info("Extracting audio from video...")
-        audio_path = extract_audio(temp_file_path)
-    else:
-        audio_path = temp_file_path  # If already audio, use it as is
-
-    # Transcribe audio to text with progress spinner
-    with st.spinner("Transcribing audio..."):
-        transcription = transcribe_audio(audio_path)
-    st.success("Transcription completed!")
-    st.write("### Transcription:")
-    st.write(transcription)
-    
-    # Summarize transcription if enabled
-    if enable_summary:
-        with st.spinner("Generating summary..."):
-            summary = summarize_text(transcription)
-        st.success("Summary generated!")
-        st.write("### Summary:")
-        st.write(summary)
-
-    # Cleanup temporary files
-    os.remove(temp_file_path)
-    if media_file.name.endswith(('.mp4', '.mov', '.avi', '.mkv')):
-        os.remove(audio_path)
-
-# Run the app and handle file upload state
-if uploaded_file is not None:
-    st.info("Processing your file...")
-    process_media(uploaded_file)
-else:
-    st.warning("Please upload an audio or video file to begin.")
-
-
-
-
-
-
-
-
-
-
-
-
-
-# # # Set your Groq API key here or use environment variable
-# # GROQ_API_TOKEN = os.getenv("groq_api")
-# # client = Groq(api_key=GROQ_API_TOKEN)
-
 # import os
 # import ffmpeg
 # import whisper
 # import streamlit as st
 # from groq import Groq
 
-# # Set the title and description of the app
-# st.title("Audio/Video Transcription and Summarization")
-# st.write("Upload your audio or video file, and this app will transcribe the audio and provide a summary of the transcription.")
+# # Set the app title and description with styling
+# st.set_page_config(page_title="Audio/Video Transcription & Summarization", page_icon="🎙️")
+# st.title("🎙️ Audio/Video Transcription & Summarization")
+# st.write("Easily upload an audio or video file to get a transcription and a quick summary.")
+
+# # Add a sidebar for settings and instructions
+# with st.sidebar:
+#     st.header("Settings")
+#     st.write("Configure app preferences here.")
+#     enable_summary = st.checkbox("Enable Summarization", value=True)
+#     st.info("Note: Summarization uses the Groq API.")
 
 # # Retrieve the API key from environment variables or Streamlit secrets
 # GROQ_API_KEY = os.getenv("GROQ_API_KEY") or st.secrets["GROQ_API_KEY"]
 # os.environ["GROQ_API_KEY"] = GROQ_API_KEY
 
-# # Create a temporary directory if it does not exist
+# # Create a temporary directory
 # temp_dir = "temp"
 # os.makedirs(temp_dir, exist_ok=True)
 
-# # Upload the audio or video file
+# # Display file uploader with improved layout and style
+# st.subheader("Upload Audio/Video File")
 # uploaded_file = st.file_uploader("Choose an audio or video file...", type=["mp4", "mov", "avi", "mkv", "wav", "mp3"])
 
 # # Function to extract audio from video
@@ -142,13 +35,13 @@ else:
 #         # Run ffmpeg command with stderr capture for better error handling
 #         ffmpeg.input(video_path).output(audio_path).run(overwrite_output=True, capture_stdout=True, capture_stderr=True)
 #     except ffmpeg.Error as e:
-#         st.error("FFmpeg error encountered: " + e.stderr.decode())
+#         st.error("Error processing file with FFmpeg: " + e.stderr.decode())
 #     return audio_path
 
-# # Function to transcribe audio to text using Whisper model
+# # Function to transcribe audio using Whisper model
 # def transcribe_audio(audio_path):
 #     """Transcribes audio to text using Whisper model."""
-#     model = whisper.load_model("base")  # Load the Whisper model
+#     model = whisper.load_model("base")
 #     result = model.transcribe(audio_path)
 #     return result["text"]
 
@@ -163,131 +56,212 @@ else:
 #     summary = response.choices[0].message.content
 #     return summary
 
-# # Complete function to process audio or video
+# # Main processing function with progress indicators
 # def process_media(media_file):
-#     """Processes audio or video: extracts audio, transcribes it, and summarizes the transcription."""
+#     """Processes audio or video: extracts audio, transcribes it, and summarizes the transcription if enabled."""
 #     # Save the uploaded file to a temporary path
 #     temp_file_path = os.path.join(temp_dir, media_file.name)
 #     with open(temp_file_path, "wb") as f:
 #         f.write(media_file.getbuffer())
 
-#     # Determine if the file is a video or audio based on the file extension
+#     # Determine if the file is a video or audio
 #     if media_file.name.endswith(('.mp4', '.mov', '.avi', '.mkv')):
-#         # Step 1: Extract audio from video
+#         st.info("Extracting audio from video...")
 #         audio_path = extract_audio(temp_file_path)
 #     else:
-#         audio_path = temp_file_path  # If it's already audio, use it as is
+#         audio_path = temp_file_path  # If already audio, use it as is
 
-#     # Step 2: Transcribe audio to text
-#     transcription = transcribe_audio(audio_path)
+#     # Transcribe audio to text with progress spinner
+#     with st.spinner("Transcribing audio..."):
+#         transcription = transcribe_audio(audio_path)
+#     st.success("Transcription completed!")
 #     st.write("### Transcription:")
 #     st.write(transcription)
     
-#     # Step 3: Summarize transcription
-#     summary = summarize_text(transcription)
-#     st.write("### Summary:")
-#     st.write(summary)
-    
-#     # Clean up temporary files if needed
+#     # Summarize transcription if enabled
+#     if enable_summary:
+#         with st.spinner("Generating summary..."):
+#             summary = summarize_text(transcription)
+#         st.success("Summary generated!")
+#         st.write("### Summary:")
+#         st.write(summary)
+
+#     # Cleanup temporary files
 #     os.remove(temp_file_path)
 #     if media_file.name.endswith(('.mp4', '.mov', '.avi', '.mkv')):
 #         os.remove(audio_path)
 
-# # Run the app
+# # Run the app and handle file upload state
 # if uploaded_file is not None:
+#     st.info("Processing your file...")
 #     process_media(uploaded_file)
 # else:
-#     st.warning("Please upload a file.")
+#     st.warning("Please upload an audio or video file to begin.")
 
 
 
 
-# ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
 
 
 
-# import os
-# import ffmpeg
-# import whisper
-# import streamlit as st
-# from groq import Groq
 
-# # Set the title and description of the app
-# st.title("Audio/Video Transcription and Summarization")
-# st.write("Upload your audio or video file, and this app will transcribe the audio and provide a summary of the transcription.")
 
-# # Get the API key from user input (You may want to use Streamlit secrets management)
-# GROQ_API_KEY = st.text_input("Enter your Groq API Key:")
-# os.environ["GROQ_API_KEY"] = GROQ_API_KEY
 
-# # Create a temporary directory if it does not exist
-# temp_dir = "temp"
-# os.makedirs(temp_dir, exist_ok=True)
+import os
+import ffmpeg
+import whisper
+import streamlit as st
+from groq import Groq
 
-# # Upload the audio or video file
-# uploaded_file = st.file_uploader("Choose an audio or video file...", type=["mp4", "mov", "avi", "mkv", "wav", "mp3"])
+# Custom CSS for styling
+st.markdown("""
+    <style>
+    /* Background gradient and color settings */
+    .stApp {
+        background-image: linear-gradient(to right, #2e2e2e, #454545);
+        color: white;
+        font-family: Arial, sans-serif;
+    }
+    /* Container box styling */
+    .container {
+        background-color: #333;
+        padding: 2rem;
+        border-radius: 10px;
+        box-shadow: 0px 4px 12px rgba(0, 0, 0, 0.4);
+    }
+    /* Header styling */
+    .header {
+        color: #ffdd40;
+        text-align: center;
+        font-size: 2.5rem;
+        margin-bottom: 1.5rem;
+    }
+    /* Subheader styling */
+    .subheader {
+        color: #f0f0f0;
+        text-align: center;
+        font-size: 1.2rem;
+        margin-bottom: 2rem;
+    }
+    /* Button styling */
+    .stButton>button {
+        background-color: #ffdd40;
+        color: #333;
+        border-radius: 5px;
+        padding: 0.6rem 1.5rem;
+        font-size: 1rem;
+        font-weight: bold;
+    }
+    .stButton>button:hover {
+        background-color: #ffcc00;
+        color: #222;
+    }
+    /* Footer styling */
+    .footer {
+        text-align: center;
+        color: #cfcfcf;
+        font-size: 0.9rem;
+        margin-top: 2rem;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# App title and description with styling
+st.markdown("<div class='header'>🎙️ Audio/Video Transcription & Summarization</div>", unsafe_allow_html=True)
+st.markdown("<div class='subheader'>Upload an audio or video file to get a transcription and a concise summary.</div>", unsafe_allow_html=True)
+
+# Sidebar for settings and instructions
+with st.sidebar:
+    st.header("Settings")
+    st.write("Customize your preferences:")
+    enable_summary = st.checkbox("Enable Summarization", value=True)
+    st.info("Note: Summarization uses the Groq API.")
 
-# # Function to extract audio from video
-# def extract_audio(video_path, audio_path="temp/temp_audio.wav"):
-#     """Extracts audio from video."""
-#     try:
-#         # Run ffmpeg command with stderr capture for better error handling
-#         ffmpeg.input(video_path).output(audio_path).run(overwrite_output=True, capture_stdout=True, capture_stderr=True)
-#     except ffmpeg.Error as e:
-#         st.error("FFmpeg error encountered: " + e.stderr.decode())
-#     return audio_path
+# Retrieve the API key from environment variables or Streamlit secrets
+GROQ_API_KEY = os.getenv("GROQ_API_KEY") or st.secrets["GROQ_API_KEY"]
+os.environ["GROQ_API_KEY"] = GROQ_API_KEY
 
-# # Function to transcribe audio to text using Whisper model
-# def transcribe_audio(audio_path):
-#     """Transcribes audio to text using Whisper model."""
-#     model = whisper.load_model("base")  # Load the Whisper model
-#     result = model.transcribe(audio_path)
-#     return result["text"]
+# Create a temporary directory
+temp_dir = "temp"
+os.makedirs(temp_dir, exist_ok=True)
 
-# # Function to summarize text using Groq API
-# def summarize_text(text):
-#     """Summarizes text using Groq API."""
-#     client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
-#     response = client.chat.completions.create(
-#         messages=[{"role": "user", "content": f"Summarize the following text: {text}"}],
-#         model="llama3-8b-8192"
-#     )
-#     summary = response.choices[0].message.content
-#     return summary
+# Enhanced file upload area
+st.markdown("<div class='container'>", unsafe_allow_html=True)
+uploaded_file = st.file_uploader(
+    label="Select an audio or video file",
+    type=["mp4", "mov", "avi", "mkv", "wav", "mp3"],
+    help="Supported formats: mp4, mov, avi, mkv, wav, mp3"
+)
 
-# # Complete function to process audio or video
-# def process_media(media_file):
-#     """Processes audio or video: extracts audio, transcribes it, and summarizes the transcription."""
-#     # Save the uploaded file to a temporary path
-#     temp_file_path = os.path.join(temp_dir, media_file.name)
-#     with open(temp_file_path, "wb") as f:
-#         f.write(media_file.getbuffer())
+# Function to extract audio from video
+def extract_audio(video_path, audio_path="temp/temp_audio.wav"):
+    try:
+        ffmpeg.input(video_path).output(audio_path).run(overwrite_output=True, capture_stdout=True, capture_stderr=True)
+    except ffmpeg.Error as e:
+        st.error("Error processing file with FFmpeg: " + e.stderr.decode())
+    return audio_path
 
-#     # Determine if the file is a video or audio based on the file extension
-#     if media_file.name.endswith(('.mp4', '.mov', '.avi', '.mkv')):
-#         # Step 1: Extract audio from video
-#         audio_path = extract_audio(temp_file_path)
-#     else:
-#         audio_path = temp_file_path  # If it's already audio, use it as is
+# Function to transcribe audio using Whisper model
+def transcribe_audio(audio_path):
+    model = whisper.load_model("base")
+    result = model.transcribe(audio_path)
+    return result["text"]
 
-#     # Step 2: Transcribe audio to text
-#     transcription = transcribe_audio(audio_path)
-#     st.write("### Transcription:")
-#     st.write(transcription)
-    
-#     # Step 3: Summarize transcription
-#     summary = summarize_text(transcription)
-#     st.write("### Summary:")
-#     st.write(summary)
+# Function to summarize text using Groq API
+def summarize_text(text):
+    client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+    response = client.chat.completions.create(
+        messages=[{"role": "user", "content": f"Summarize the following text: {text}"}],
+        model="llama3-8b-8192"
+    )
+    summary = response.choices[0].message.content
+    return summary
+
+# Main processing function with progress indicators
+def process_media(media_file):
+    temp_file_path = os.path.join(temp_dir, media_file.name)
+    with open(temp_file_path, "wb") as f:
+        f.write(media_file.getbuffer())
+
+    # Extract audio if the file is a video
+    if media_file.name.endswith(('.mp4', '.mov', '.avi', '.mkv')):
+        st.info("Extracting audio from video...")
+        audio_path = extract_audio(temp_file_path)
+    else:
+        audio_path = temp_file_path
+
+    # Transcribe audio
+    with st.spinner("Transcribing audio..."):
+        transcription = transcribe_audio(audio_path)
+    st.success("Transcription completed!")
+    st.write("### Transcription:")
+    st.write(transcription)
     
-#     # Clean up temporary files if needed
-#     os.remove(temp_file_path)
-#     if media_file.name.endswith(('.mp4', '.mov', '.avi', '.mkv')):
-#         os.remove(audio_path)
+    # Summarize transcription if enabled
+    if enable_summary:
+        with st.spinner("Generating summary..."):
+            summary = summarize_text(transcription)
+        st.success("Summary generated!")
+        st.write("### Summary:")
+        st.write(summary)
 
-# # Run the app
-# if uploaded_file is not None and GROQ_API_KEY:
-#     process_media(uploaded_file)
-# else:
-#     st.warning("Please upload a file and enter your Groq API key.")
+    # Cleanup
+    os.remove(temp_file_path)
+    if media_file.name.endswith(('.mp4', '.mov', '.avi', '.mkv')):
+        os.remove(audio_path)
+
+if uploaded_file:
+    st.info("Processing your file, please wait...")
+    process_media(uploaded_file)
+else:
+    st.warning("Please upload an audio or video file to begin.")
+
+# Footer with branding
+st.markdown("""
+    <div class="footer">
+        &copy; 2024 TranscribePro. Developed by Abdullah Zunorain.
+    </div>
+""", unsafe_allow_html=True)
+
+st.markdown("</div>", unsafe_allow_html=True)