Update app.py

app.py

@@ -1,9 +1,11 @@
 import streamlit as st
 import ffmpeg
 import os
+import time
 from PIL import Image
 import re
 import tempfile
+import shutil
 
 st.set_page_config(layout="wide", page_title="Video Conversion Tool")
 
@@ -11,63 +13,67 @@ st.set_page_config(layout="wide", page_title="Video Conversion Tool")
 supported_formats = sorted(['3GP', 'ASF', 'AVI', 'DIVX', 'FLV', 'M2TS', 'M4V', 'MKV', 'MOV', 'MP4', 'MPEG', 'MPG', 'MTS', 'TS', 'VOB', 'WEBM', 'WMV', 'XVID'])
 audio_formats = sorted(['MP3', 'WAV', 'AAC', 'FLAC', 'OGG', 'M4A', 'ALAC', 'WMA', 'AIFF', 'OPUS', 'APE', 'CAF', 'PCM', 'DTS', 'TTA', 'AMR', 'MID', 'SPX', 'WV', 'RA', 'TAK'])
 gif_formats = ['GIF']
-image_formats = sorted(Image.SAVE.keys()) or ['BLP', 'BMP', 'BUFR', 'DDS', 'DIB', 'EPS',
-                                              'GIF', 'GRIB', 'HDF5', 'ICNS', 'ICO', 'IM',
-                                              'JPEG', 'JPEG2000', 'MPO', 'MSP', 'PALM', 'PCX',
-                                              'PDF', 'PNG', 'PPM', 'SGI', 'SPIDER', 'TGA', 'TIFF',
-                                              'WEBP', 'WMX', 'XBM']
+image_formats = sorted(Image.SAVE.keys()) or ['BLP', 'BMP', 'BUFR', 'DDS', 'DIB', 'EPS', 'GIF', 'GRIB', 'HDF5', 'ICNS', 'ICO', 'IM',
+                                              'JPEG', 'JPEG2000', 'MPO', 'MSP', 'PALM', 'PCX', 'PDF', 'PNG', 'PPM', 'SGI', 'SPIDER', 
+                                              'TGA', 'TIFF', 'WEBP', 'WMX', 'XBM']
+
+CACHE_DIR = tempfile.mkdtemp()
 
 def sanitize_filename(filename):
     """Sanitize filename by removing special characters and spaces."""
-    filename = re.sub(r'[^a-zA-Z0-9_.-]', '_', filename)  # Replace invalid characters with '_'
-    return filename
+    return re.sub(r'[^a-zA-Z0-9_.-]', '_', filename)
+
+def clean_cache():
+    """Remove files in the cache directory older than 15 minutes."""
+    now = time.time()
+    for file in os.listdir(CACHE_DIR):
+        file_path = os.path.join(CACHE_DIR, file)
+        if os.path.isfile(file_path) and now - os.path.getmtime(file_path) > 900:  # 15 minutes
+            os.remove(file_path)
 
 def get_video_duration(video_path):
     """Get video duration in seconds using ffmpeg."""
     probe = ffmpeg.probe(video_path, v='error', select_streams='v:0', show_entries='stream=duration')
-    duration_in_seconds = float(probe['streams'][0]['duration'])
-    return duration_in_seconds
+    return float(probe['streams'][0]['duration'])
 
 def convert_video(video, target_format, conversion_type, time_in_seconds=None):
     try:
-        # Create a temporary directory for the uploaded file
-        temp_dir = tempfile.mkdtemp()
+        clean_cache()  # Clean up cache before processing
 
-        # Sanitize the filename and save the uploaded video to the temp directory
-        base_name = os.path.splitext(os.path.basename(video.name))[0]
-        sanitized_base_name = sanitize_filename(base_name)
-        video_path = os.path.join(temp_dir, f"{sanitized_base_name}.mp4")  # Saving as mp4 by default for now
+        # Save the uploaded video to the temp directory
+        sanitized_base_name = sanitize_filename(os.path.splitext(video.name)[0])
+        video_path = os.path.join(CACHE_DIR, f"{sanitized_base_name}.mp4")
 
         with open(video_path, "wb") as f:
-            f.write(video.getbuffer())  # Save the uploaded video to a local file
+            f.write(video.getbuffer())
 
         if conversion_type == 'Video to Video':
-            output_file = f"flowly_ai_video_converter_{sanitized_base_name}.{target_format.lower()}"
-            ffmpeg.input(video_path).output(output_file).run()  # Use ffmpeg.input properly
+            output_file = os.path.join(CACHE_DIR, f"flowly_ai_video_converter_{sanitized_base_name}.{target_format.lower()}")
+            ffmpeg.input(video_path).output(output_file, overwrite_output=True).run(overwrite_output=True)
             return output_file
 
         elif conversion_type == 'Video to Audio':
-            audio_output_file = f"flowly_ai_video_to_audio_{sanitized_base_name}.{target_format.lower()}"
-            ffmpeg.input(video_path).output(audio_output_file).run()  # Use ffmpeg.input properly
-            return audio_output_file
+            output_file = os.path.join(CACHE_DIR, f"flowly_ai_video_to_audio_{sanitized_base_name}.{target_format.lower()}")
+            ffmpeg.input(video_path).output(output_file, overwrite_output=True).run(overwrite_output=True)
+            return output_file
 
         elif conversion_type == 'Video to GIF':
-            gif_output_file = f"flowly_ai_video_to_gif_{sanitized_base_name}.gif"
-            ffmpeg.input(video_path).output(gif_output_file, vf="fps=10,scale=320:-1:flags=lanczos").run()  # Use ffmpeg.input properly
-            return gif_output_file
+            output_file = os.path.join(CACHE_DIR, f"flowly_ai_video_to_gif_{sanitized_base_name}.gif")
+            ffmpeg.input(video_path).output(output_file, vf="fps=10,scale=320:-1:flags=lanczos", overwrite_output=True).run(overwrite_output=True)
+            return output_file
 
         elif conversion_type == 'Video to Image':
             if time_in_seconds is None:
                 return "Please specify a valid time in seconds for image extraction."
 
-            image_output_file = f"flowly_ai_video_to_image_{sanitized_base_name}_{time_in_seconds}.png"
-            ffmpeg.input(video_path, ss=time_in_seconds).output(image_output_file, vframes=1).run()  # Use ffmpeg.input properly
+            image_output_file = os.path.join(CACHE_DIR, f"flowly_ai_video_to_image_{sanitized_base_name}_{time_in_seconds}.png")
+            ffmpeg.input(video_path, ss=time_in_seconds).output(image_output_file, vframes=1, overwrite_output=True).run(overwrite_output=True)
 
             # Convert the image to the desired format using Pillow
             img = Image.open(image_output_file)
             if target_format.lower() in image_formats:
-                image_output_file = f"flowly_ai_video_to_image_{sanitized_base_name}_{time_in_seconds}.{target_format.lower()}"
-                img.save(image_output_file, target_format.upper())  # Save with the desired format
+                image_output_file = os.path.join(CACHE_DIR, f"flowly_ai_video_to_image_{sanitized_base_name}_{time_in_seconds}.{target_format.lower()}")
+                img.save(image_output_file, target_format.upper())
 
             return image_output_file
 
@@ -101,8 +107,8 @@ def main():
 
     with col2:
         if video_file:
-            # Create a temporary file and save uploaded video
-            temp_video_path = os.path.join(tempfile.mkdtemp(), video_file.name)
+            # Save uploaded video to cache
+            temp_video_path = os.path.join(CACHE_DIR, video_file.name)
             with open(temp_video_path, "wb") as f:
                 f.write(video_file.getbuffer())
 
@@ -134,16 +140,17 @@ def main():
             if st.button("Convert"):
                 with st.spinner("Converting..."):
                     output_file = convert_video(video_file, target_format, conversion_type, time_in_seconds)
-                    
+
                     if "Error" in output_file:
                         st.error(output_file)
                     else:
-                        st.success(f"Conversion Successful! Download the file:")
+                        st.success("Conversion Successful! Download the file:")
                         st.download_button(
                             label="Download Converted File", 
                             data=open(output_file, 'rb').read(), 
-                            file_name=output_file
+                            file_name=os.path.basename(output_file)
                         )
 
 if __name__ == "__main__":
     main()
+