Update app.py

app.py

@@ -6,24 +6,16 @@ import streamlit as st
 import tempfile
 import time
 import re
+import base64
 from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
 from langchain_groq import ChatGroq
 from langchain.schema import HumanMessage
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
-from google.auth.transport.requests import Request
-from googleapiclient.discovery import build
-from googleapiclient.http import MediaFileUpload
-import pickle
 
 # Constants
 MAX_CHUNK_SIZE = 3000  # Characters per chunk
 SEGMENT_DURATION = 120  # Seconds for each segment
 MODEL_NAME = "deepseek-r1-distill-llama-70b"
 
-# Google Drive API setup
-SCOPES = ['https://www.googleapis.com/auth/drive.file']
-
 st.set_page_config(page_title="YouTube Video Processor", layout="wide")
 st.title("YouTube Video Processor")
 
@@ -36,75 +28,36 @@ with st.sidebar:
                           ["ar", "en", "fr", "es", "de", "it", "ja", "ko", "pt", "ru", "zh"],
                           index=0)
     
-    st.header("Google Drive Connection")
-    st.info("You'll need to authorize this app to upload files to your Google Drive")
-    
-    upload_to_drive = st.checkbox("Upload to Google Drive", value=True)
-    
-    if upload_to_drive:
-        uploaded_credentials = st.file_uploader("Upload your client_secret.json", type="json", 
-                                              help="Download from Google Cloud Console")
+    max_segments = st.slider("Maximum number of segments", 5, 30, 15)
 
-# Function to authenticate with Google Drive
-@st.cache_resource
-def authenticate_google_drive(credentials_file=None):
-    creds = None
-    
-    # Check if we have token.pickle
-    token_path = "token.pickle"
-    if os.path.exists(token_path):
-        with open(token_path, 'rb') as token:
-            creds = pickle.load(token)
-    
-    # If there are no (valid) credentials, let the user log in
-    if not creds or not creds.valid:
-        if creds and creds.expired and creds.refresh_token:
-            creds.refresh(Request())
-        else:
-            if credentials_file:
-                # Save credentials file to temporary location
-                with tempfile.NamedTemporaryFile(delete=False, suffix='.json') as tmp_file:
-                    tmp_file.write(credentials_file.getvalue())
-                    credentials_path = tmp_file.name
-                
-                flow = InstalledAppFlow.from_client_secrets_file(credentials_path, SCOPES)
-                creds = flow.run_local_server(port=0)
-                os.unlink(credentials_path)  # Delete the temp file
-            else:
-                return None
-        
-        # Save the credentials for the next run
-        with open(token_path, 'wb') as token:
-            pickle.dump(creds, token)
-    
-    return creds
-
-# Create Drive service
-def create_drive_service(creds):
-    return build('drive', 'v3', credentials=creds)
-
-# Function to upload file to Google Drive
-def upload_to_google_drive(drive_service, file_path, folder_id=None):
-    file_name = os.path.basename(file_path)
-    file_metadata = {'name': file_name}
-    
-    if folder_id:
-        file_metadata['parents'] = [folder_id]
-    
-    media = MediaFileUpload(file_path, resumable=True)
-    file = drive_service.files().create(body=file_metadata, media_body=media, fields='id').execute()
-    
-    return file.get('id')
+# Function to create a download link for a file
+def get_download_link(file_path, link_text):
+    with open(file_path, 'rb') as f:
+        data = f.read()
+    b64 = base64.b64encode(data).decode()
+    filename = os.path.basename(file_path)
+    href = f'<a href="data:video/mp4;base64,{b64}" download="{filename}">{link_text}</a>'
+    return href
 
-# Function to create folder in Google Drive
-def create_drive_folder(drive_service, folder_name):
-    folder_metadata = {
-        'name': folder_name,
-        'mimeType': 'application/vnd.google-apps.folder'
-    }
+# Function to create a download link for all files as ZIP
+def get_zip_download_link(files, output_name):
+    if not files:
+        return ""
     
-    folder = drive_service.files().create(body=folder_metadata, fields='id').execute()
-    return folder.get('id')
+    # Create a temporary zip file
+    zip_path = f"{output_name}.zip"
+    try:
+        cmd = ['zip', '-j', zip_path] + files
+        subprocess.run(cmd, check=True)
+        
+        with open(zip_path, 'rb') as f:
+            data = f.read()
+        b64 = base64.b64encode(data).decode()
+        href = f'<a href="data:application/zip;base64,{b64}" download="{output_name}.zip">Download All Segments (ZIP)</a>'
+        return href
+    except Exception as e:
+        st.error(f"Error creating ZIP file: {e}")
+        return ""
 
 # Video processing functions from your original script
 def get_video_transcript(video_id, language):
@@ -193,12 +146,12 @@ def extract_questions_from_transcript(transcript, api_key, progress_bar=None):
         except Exception as e:
             st.warning(f"Error extracting questions for chunk {i+1}: {e}")
     
-    # Remove duplicates and limit to 30 questions
+    # Remove duplicates and limit to max_segments questions
     unique_questions = []
     for q in all_questions:
         if q not in unique_questions and q:
             unique_questions.append(q)
-            if len(unique_questions) >= 30:
+            if len(unique_questions) >= max_segments:
                 break
                 
     return unique_questions
@@ -364,7 +317,7 @@ if st.button("Process Video"):
         os.makedirs(final_dir, exist_ok=True)
         
         # Process tab layout
-        tab1, tab2, tab3, tab4, tab5 = st.tabs(["Transcript", "Questions", "Video", "Segments", "Upload"])
+        tab1, tab2, tab3, tab4, tab5 = st.tabs(["Transcript", "Questions", "Video", "Segments", "Download"])
         
         # Tab 1: Extract transcript
         with tab1:
@@ -423,7 +376,7 @@ if st.button("Process Video"):
                 
                 # Create segments
                 st.subheader("Creating Segments")
-                segments = create_segment_timestamps(transcript, num_segments=min(30, len(questions)))
+                segments = create_segment_timestamps(transcript, num_segments=min(max_segments, len(questions)))
                 st.write(f"Created {len(segments)} segments")
             else:
                 download_progress.progress(1.0, text="Failed to download video")
@@ -457,51 +410,32 @@ if st.button("Process Video"):
                 segment_progress.progress(1.0, text="Failed to create segments")
                 st.stop()
         
-        # Tab 5: Upload to Google Drive
+        # Tab 5: Download segments
         with tab5:
-            st.header("Upload to Google Drive")
+            st.header("Download Video Segments")
             
-            if upload_to_drive and uploaded_credentials:
-                upload_progress = st.progress(0, text="Preparing Google Drive upload...")
+            if final_files:
+                st.subheader("Individual Downloads")
                 
-                # Authenticate with Google Drive
-                creds = authenticate_google_drive(uploaded_credentials)
+                # Create 3 columns for better layout
+                cols = st.columns(3)
+                for i, file_path in enumerate(final_files):
+                    col_idx = i % 3
+                    filename = os.path.basename(file_path)
+                    download_link = get_download_link(file_path, f"Download: {filename}")
+                    cols[col_idx].markdown(download_link, unsafe_allow_html=True)
                 
-                if creds:
-                    drive_service = create_drive_service(creds)
-                    
-                    # Create folder for videos
-                    folder_name = f"YouTube_Segments_{video_id}_{time.strftime('%Y%m%d-%H%M%S')}"
-                    folder_id = create_drive_folder(drive_service, folder_name)
-                    
-                    st.write(f"Created Google Drive folder: {folder_name}")
-                    
-                    # Upload files
-                    uploaded_files = []
-                    for i, file_path in enumerate(final_files):
-                        upload_progress.progress((i + 1) / len(final_files), 
-                                              text=f"Uploading file {i+1}/{len(final_files)}")
-                        
-                        file_id = upload_to_google_drive(drive_service, file_path, folder_id)
-                        if file_id:
-                            uploaded_files.append((os.path.basename(file_path), file_id))
-                    
-                    upload_progress.progress(1.0, text=f"Uploaded {len(uploaded_files)} files to Google Drive")
-                    
-                    # Display uploaded files
-                    st.subheader("Uploaded Files")
-                    for filename, file_id in uploaded_files:
-                        st.write(f"- {filename}")
-                    
-                    st.success(f"All {len(uploaded_files)} files have been uploaded to Google Drive in folder '{folder_name}'")
-                else:
-                    upload_progress.progress(1.0, text="Failed to authenticate with Google Drive")
-                    st.error("Google Drive authentication failed. Please check your credentials file.")
+                st.subheader("Download All Segments")
+                zip_name = f"video_segments_{video_id}"
+                zip_link = get_zip_download_link(final_files, zip_name)
+                if zip_link:
+                    st.markdown(zip_link, unsafe_allow_html=True)
+                    st.info("The zip file contains all processed video segments with descriptive filenames.")
             else:
-                st.info("Google Drive upload was not selected or credentials were not provided.")
+                st.warning("No segments available for download.")
         
-        # Cleanup temporary files
-        st.write("Processing complete! Temporary files will be cleaned up automatically.")
+        # Cleanup message
+        st.success("Processing complete! You can download the video segments from the Download tab.")
 
 # Additional info
 with st.expander("About this app"):
@@ -511,27 +445,11 @@ with st.expander("About this app"):
     2. Using LLM to identify key questions answered in the video
     3. Splitting the video into segments
     4. Naming each segment based on the questions
-    5. Uploading the segments to Google Drive (optional)
+    5. Providing download links for all segments
     
     To use the app, you need:
     - A GROQ API key
     - A YouTube video ID
-    - Google Drive credentials (if uploading to Drive)
     
     The app works best with videos that have transcripts available.
-    """)
-
-# Instructions for Google Drive setup
-with st.expander("How to set up Google Drive Integration"):
-    st.write("""
-    ### Setting up Google Drive API Access
-    
-    1. Go to the [Google Cloud Console](https://console.cloud.google.com/)
-    2. Create a new project or select an existing one
-    3. Enable the Google Drive API
-    4. Create OAuth 2.0 credentials (Desktop app type)
-    5. Download the credentials JSON file
-    6. Upload the file to this app when prompted
-    
-    After authentication, the app will be able to upload files to your Google Drive.
     """)