Add application files and dependencies

app.py

@@ -11,6 +11,9 @@ import uuid
 import shutil
 import re
 import time
+import threading
+job_statuses = {}
+
 
 
 def check_dependencies():
@@ -182,12 +185,10 @@ def process_video(url):
                 continue
 
         return trimmed_dir
-
 def main():
     st.title("⚡️ ISKM Spotify Service 🛎️")
     sac.alert(label='🪷🌹🪷Hare Krishna 🪷🌹🪷 | 🙌dandwat 🙇 pranam🙌 | 🙏please accept my humble obeisances | 🫡 🪷🌹All glories Srila Prabhupada🌹🪷🫡 | 🎵 Welcome to ISKM Spotify Service! 🎶 | 🎧 Enter a YouTube URL to transform it into divine format 🙏  ✅ v0.0.2 Nanda Gopa 👶🏻 Stage | 🚧 Maintaince Mode', size='xs', radius=55, color='orange', banner=sac.Banner(play=True, direction='right', speed=51, pauseOnHover=True), icon=True, closable=True)
 
-
     # Add instruction guide in an expander
     with st.expander("📚 Instructions"):
         st.markdown("""
@@ -218,35 +219,50 @@ def main():
         If you encounter any issues, please check the dependency status in the sidebar or contact support.
         """)
 
+
+    # Your existing instruction guide code here
+
     url = st.text_input("Enter the YouTube URL:")
+    job_id = st.text_input("Enter Job ID (optional):")
 
     if st.button("Process Video"):
         if url:
             with st.spinner("Processing video..."):
-                result = process_video(url)
+                result, error = process_video(url)
             
             if result:
-                if os.path.isfile(result):
-                    st.success("Video processing completed!")
-                    st.download_button(
-                        label="Download Processed Video",
-                        data=open(result, 'rb'),
-                        file_name=os.path.basename(result),
-                        mime="video/mp4"
-                    )
-                elif os.path.isdir(result):
-                    st.success("Playlist processing completed!")
-                    for video in glob.glob(f"{result}/*_f.mp4"):
+                st.success(f"Video processing completed! Job ID: {os.path.basename(os.path.dirname(result))}")
+                st.session_state['job_id'] = os.path.basename(os.path.dirname(result))
+            else:
+                st.error(f"An error occurred during processing: {error}")
+        else:
+            st.warning("Please enter a YouTube URL.")
+
+    if st.button("Check Job Status"):
+        if job_id:
+            status = get_job_status(job_id)
+            st.info(f"Job Status: {status}")
+            if status == "Completed":
+                result = get_job_result(job_id)
+                if result:
+                    if os.path.isfile(result):
                         st.download_button(
-                            label=f"Download {os.path.basename(video)}",
-                            data=open(video, 'rb'),
-                            file_name=os.path.basename(video),
+                            label="Download Processed Video",
+                            data=open(result, 'rb'),
+                            file_name=os.path.basename(result),
                             mime="video/mp4"
                         )
-            else:
-                st.error("An error occurred during processing.")
+                    elif os.path.isdir(result):
+                        for video in glob.glob(f"{result}/*_f.mp4"):
+                            st.download_button(
+                                label=f"Download {os.path.basename(video)}",
+                                data=open(video, 'rb'),
+                                file_name=os.path.basename(video),
+                                mime="video/mp4"
+                            )
         else:
-            st.warning("Please enter a YouTube URL.")
+            st.warning("Please enter a Job ID.")
 
 if __name__ == "__main__":
+    check_dependencies()
     main()

process_video.py

@@ -1,70 +1,167 @@
-import sys
-import json
 import os
-from datetime import datetime
+import glob
 import subprocess
+import uuid
 import re
-import glob
+import select
+import shutil
+import time
+import streamlit as st
+
+
 
-def run_command_with_progress(command, job_info, tool):
+def run_command_with_progress(command, status_placeholder, progress_bar, tool_name, is_trimming=False):
     process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, universal_newlines=True)
     
-    while True:
-        output = process.stdout.readline()
-        if output == '' and process.poll() is not None:
-            break
-        if output:
-            print(output.strip())
-            update_job_status(job_info, f"{tool}: {output.strip()}")
+    status_placeholder.text(f"Using {tool_name}...")
+    
+    output_lines = []
+    error_lines = []
+    
+    duration = None
     
-    return process.poll()
+    while True:
+        reads = [process.stdout.fileno(), process.stderr.fileno()]
+        ret = select.select(reads, [], [], 0.1)
+
+        for fd in ret[0]:
+            if fd == process.stdout.fileno():
+                read = process.stdout.readline()
+                if read:
+                    output_lines.append(read.strip())
+                    status_placeholder.text(f"{tool_name}: {read.strip()}")
+                    
+                    if '[download]' in read:
+                        match = re.search(r'(\d+\.\d+)%', read)
+                        if match:
+                            progress = min(float(match.group(1)), 100) / 100
+                            progress_bar.progress(progress)
+            
+            if fd == process.stderr.fileno():
+                read = process.stderr.readline()
+                if read:
+                    error_lines.append(read.strip())
+                    
+                    # Parse ffmpeg output
+                    if tool_name == "ffmpeg":
+                        duration_match = re.search(r'Duration: (\d{2}):(\d{2}):(\d{2}\.\d{2})', read)
+                        if duration_match:
+                            hours, minutes, seconds = map(float, duration_match.groups())
+                            duration = hours * 3600 + minutes * 60 + seconds
 
-def update_job_status(job_info, status):
-    job_info["status"] = status
-    with open(f"{job_info['output_dir']}/job_info.json", "w") as f:
-        json.dump(job_info, f)
+                        time_match = re.search(r'time=(\d{2}):(\d{2}):(\d{2}\.\d{2})', read)
+                        if time_match and duration:
+                            hours, minutes, seconds = map(float, time_match.groups())
+                            current_time = hours * 3600 + minutes * 60 + seconds
+                            progress = min((current_time / duration), 1)
+                            status_placeholder.text(f"{tool_name}: {progress*100:.2f}% complete")
+                            progress_bar.progress(progress)
 
-def process_video(job_id, url):
-    output_dir = f"./output_folder_{job_id}"
+        if process.poll() is not None:
+            break
     
-    with open(f"{output_dir}/job_info.json", "r") as f:
-        job_info = json.load(f)
+    return_code = process.poll()
     
-    update_job_status(job_info, "downloading")
+    if return_code != 0:
+        st.error(f"Error occurred during {tool_name} processing:")
+        for line in error_lines[-10:]:  # Display last 10 error lines
+            st.error(line)
     
+    return return_code
+
+def process_video(url, status_callback=None):
+    session_id = str(uuid.uuid4())
+    output_dir = f"./output_folder_{session_id}"
+    os.makedirs(output_dir, exist_ok=True)
+
+    for file in glob.glob(f"{output_dir}/*"):
+        os.remove(file)
+
+    content_type = "playlist" if "list=" in url else "video"
     format = "bestvideo[height<=1080][ext=mp4]+bestaudio[ext=m4a]/best[height<=1080][ext=mp4]"
     download_command = f'yt-dlp --cookies cookies.txt -f "{format}" -N 64 -o "{output_dir}/%(title)s.%(ext)s" "{url}"'
     
-    return_code = run_command_with_progress(download_command, job_info, "yt-dlp")
+    status_placeholder = st.empty() if status_callback is None else status_callback
+    progress_bar = st.progress(0)
     
-    if return_code != 0:
-        update_job_status(job_info, "error: download failed")
-        return
-
-    video_file = glob.glob(f"{output_dir}/*.mp4")[0]
-    trimmed_file = video_file.replace(".mp4", "_trimmed.mp4")
-    
-    update_job_status(job_info, "trimming")
-    auto_editor_command = f'auto-editor "{video_file}" --margin 0.5sec --output "{trimmed_file}"'
-    return_code = run_command_with_progress(auto_editor_command, job_info, "auto-editor")
+    return_code = run_command_with_progress(download_command, status_placeholder, progress_bar, "yt-dlp")
     
     if return_code != 0:
-        update_job_status(job_info, "error: trimming failed")
-        return
+        return None, "Error occurred during download."
 
-    final_file = trimmed_file.replace("_trimmed.mp4", f"_f_{job_id}.mp4")
-    
-    update_job_status(job_info, "processing")
-    ffmpeg_command = f'ffmpeg -y -i "{trimmed_file}" -map 0:v:0 -map 0:a:0 -c:v libx264 -preset ultrafast -crf 23 -maxrate 25M -vf "scale=-1:1080" -c:a aac -b:a 192k -ac 2 -strict -2 "{final_file}"'
-    return_code = run_command_with_progress(ffmpeg_command, job_info, "ffmpeg")
-    
-    if return_code != 0:
-        update_job_status(job_info, "error: final processing failed")
-        return
+    if content_type == "video":
+        video_file = glob.glob(f"{output_dir}/*.mp4")[0]
+        trimmed_file = video_file.replace(".mp4", "_trimmed.mp4")
+        
+        progress_bar.progress(0)
+        auto_editor_command = f'auto-editor "{video_file}" --margin 0.5sec --output "{trimmed_file}"'
+        return_code = run_command_with_progress(auto_editor_command, status_placeholder, progress_bar, "auto-editor", is_trimming=True)
+        
+        if return_code != 0:
+            return None, "Error occurred during trimming."
+
+        final_file = trimmed_file.replace("_trimmed.mp4", f"_f_{session_id}.mp4")
+        
+        progress_bar.progress(0)
+        ffmpeg_command = f'ffmpeg -y -i "{trimmed_file}" -map 0:v:0 -map 0:a:0 -c:v libx264 -preset ultrafast -crf 23 -maxrate 25M -vf "scale=-1:1080" -c:a aac -b:a 192k -ac 2 -strict -2 "{final_file}"'
+        return_code = run_command_with_progress(ffmpeg_command, status_placeholder, progress_bar, "ffmpeg")
+        
+        if return_code != 0:
+            return None, "Error occurred during final processing."
+
+        return final_file, None
+
+    elif content_type == "playlist":
+        trimmed_dir = f"{output_dir}/trimmed"
+        os.makedirs(trimmed_dir, exist_ok=True)
+
+        for video_file in glob.glob(f"{output_dir}/*.mp4"):
+            video_name = os.path.basename(video_file).replace(".mp4", "")
+            trimmed_file = f"{trimmed_dir}/{video_name}_trimmed.mp4"
+            
+            progress_bar.progress(0)
+            auto_editor_command = f'auto-editor "{video_file}" --margin 0.5sec --output "{trimmed_file}" --verbose'
+            return_code = run_command_with_progress(auto_editor_command, status_placeholder, progress_bar, "auto-editor", is_trimming=True)
+            
+            if return_code != 0:
+                continue
+
+            final_file = f"{trimmed_dir}/{video_name}_f.mp4"
+            
+            progress_bar.progress(0)
+            ffmpeg_command = f'ffmpeg -y -i "{trimmed_file}" -map 0:v:0 -map 0:a:0 -c:v libx264 -preset ultrafast -crf 23 -maxrate 25M -vf "scale=-1:1080" -c:a aac -b:a 192k -ac 2 -strict -2 "{final_file}"'
+            return_code = run_command_with_progress(ffmpeg_command, status_placeholder, progress_bar, "ffmpeg")
+            
+            if return_code != 0:
+                continue
+
+        return trimmed_dir, None
+
+def get_job_status(session_id):
+    output_dir = f"./output_folder_{session_id}"
+    if not os.path.exists(output_dir):
+        return "Job not found"
+
+    if glob.glob(f"{output_dir}/*_f_{session_id}.mp4"):
+        return "Completed"
+    elif glob.glob(f"{output_dir}/trimmed/*_f.mp4"):
+        return "Completed"
+    elif glob.glob(f"{output_dir}/*.mp4"):
+        return "Processing"
+    else:
+        return "Downloading"
+
+def get_job_result(session_id):
+    output_dir = f"./output_folder_{session_id}"
+    if not os.path.exists(output_dir):
+        return None
+
+    single_video = glob.glob(f"{output_dir}/*_f_{session_id}.mp4")
+    if single_video:
+        return single_video[0]
 
-    update_job_status(job_info, "completed")
+    playlist_dir = f"{output_dir}/trimmed"
+    if os.path.exists(playlist_dir):
+        return playlist_dir
 
-if __name__ == "__main__":
-    job_id = sys.argv[1]
-    url = sys.argv[2]
-    process_video(job_id, url)
+    return None