Update app.py

app.py

@@ -1,51 +1,102 @@
 import streamlit as st
 import os
-from pipelines.video_process import extract_audio_ffmpeg, apply_edits
-from pipelines.ai_inference import transcribe_audio, generate_edit_instructions
-# from pipelines.auth_utils import check_auth_status  # If using custom
-import openai
+import subprocess
 
 def main():
-    st.title("Smart Edit Assistant 🎬")
-    # Check if user is logged in if using custom auth
-    # user_info = check_auth_status()
-    # if not user_info: 
-    #     st.stop()
-
-    openai_api_key = os.getenv("OPENAI_API_KEY", "")
-    if openai_api_key:
-        openai.api_key = openai_api_key
-    else:
-        st.warning("No OpenAI API key found in environment.")
+    st.title("Smart Edit Assistant")
 
     uploaded_file = st.file_uploader("Upload your video", type=["mp4", "mov", "mkv"])
-    if uploaded_file is not None:
+
+    if uploaded_file:
         with open("temp_input.mp4", "wb") as f:
             f.write(uploaded_file.getbuffer())
 
         st.video("temp_input.mp4")
-        
+
         if st.button("Process Video"):
+            # 1. Extract audio using FFmpeg (example)
             with st.spinner("Extracting audio..."):
                 audio_path = extract_audio_ffmpeg("temp_input.mp4", "temp_audio.wav")
 
+            # 2. Transcribe audio (placeholder function; use openai-whisper or local)
             with st.spinner("Transcribing..."):
-                transcript_text = transcribe_audio(audio_path)  # calls either local or API-based Whisper
-
+                transcript_text = transcribe_audio(audio_path)
             st.text_area("Transcript", transcript_text, height=200)
 
-            with st.spinner("Generating edit instructions with GPT..."):
+            # 3. Generate instructions (placeholder function; calls GPT or open-source LLM)
+            with st.spinner("Generating edit instructions..."):
                 edit_instructions = generate_edit_instructions(transcript_text)
+            st.write("AI Edit Instructions:", edit_instructions)
 
-            st.write(edit_instructions)
-
+            # 4. Apply Edits with FFmpeg
             with st.spinner("Applying edits..."):
                 edited_video_path = apply_edits("temp_input.mp4", edit_instructions)
-            
-            st.success("Done!")
-            st.video(edited_video_path)
-            with open(edited_video_path, "rb") as f_out:
-                st.download_button("Download Edited Video", data=f_out, file_name="edited_result.mp4", mime="video/mp4")
+
+            # 5. Verify output file
+            abs_edited_path = os.path.join(os.getcwd(), edited_video_path)
+            if not os.path.exists(abs_edited_path):
+                st.error(f"Edited video file not found at '{abs_edited_path}'. Check logs.")
+                return
+
+            file_size = os.path.getsize(abs_edited_path)
+            if file_size == 0:
+                st.error(f"Edited video file is empty (0 bytes). Check ffmpeg or editing logic.")
+                return
+
+            st.success("Edit complete! Now previewing the edited video.")
+            st.video(abs_edited_path)  # pass the absolute path
+
+            with open(abs_edited_path, "rb") as f_out:
+                st.download_button(
+                    label="Download Edited Video",
+                    data=f_out,
+                    file_name="edited_result.mp4",
+                    mime="video/mp4",
+                )
+
+def extract_audio_ffmpeg(input_video, output_audio):
+    """
+    Calls ffmpeg to extract audio. Returns path if successful; raises if not.
+    """
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", input_video,
+        "-vn",  # no video
+        "-acodec", "pcm_s16le",
+        "-ar", "16000",
+        "-ac", "1",
+        output_audio
+    ]
+    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffmpeg error: {result.stderr.decode()}")
+    return output_audio
+
+def transcribe_audio(audio_path):
+    """
+    Placeholder for your transcription logic (whisper / openai-whisper).
+    """
+    return "This is a mock transcript."
+
+def generate_edit_instructions(transcript_text):
+    """
+    Placeholder for GPT/LLM-based instructions. 
+    Return string or structured instructions (like JSON).
+    """
+    return "Keep everything; no major edits."
+
+def apply_edits(input_video, edit_instructions):
+    """
+    Demo function: We'll just copy input to output to show a valid flow.
+    In practice, you'd parse instructions & cut the video with ffmpeg or moviepy.
+    """
+    output_video = "edited_video.mp4"
+    # For demonstration, let's do a direct copy with ffmpeg:
+    cmd = ["ffmpeg", "-y", "-i", input_video, "-c", "copy", output_video]
+    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffmpeg editing error: {result.stderr.decode()}")
+    return output_video
 
 if __name__ == "__main__":
     main()