Update app.py

app.py

@@ -4,12 +4,20 @@ import tempfile
 import os
 import subprocess
 
-def download_snippet(url, duration_sec):
-    """Download and trim audio snippet"""
+def download_snippet(url, start_sec, end_sec):
+    """Download and trim audio snippet with custom start/end times"""
     # Create temp directory
     temp_dir = tempfile.mkdtemp()
     
     try:
+        # Validate times
+        if start_sec >= end_sec:
+            raise Exception("Start time must be before end time")
+        
+        duration = end_sec - start_sec
+        if duration > 600:  # Limit to 10 minutes max
+            raise Exception("Maximum duration is 600 seconds (10 minutes)")
+        
         # First, download the full track (or best we can get)
         ydl_opts = {
             'format': 'bestaudio/best',
@@ -23,6 +31,12 @@ def download_snippet(url, duration_sec):
             # Get info for filename
             info = ydl.extract_info(url, download=False)
             title = info.get('title', 'soundcloud_track')
+            duration_full = info.get('duration', 0)
+            
+            # Validate against full duration
+            if duration_full and end_sec > duration_full:
+                raise Exception(f"End time ({end_sec}s) exceeds track duration ({duration_full}s)")
+            
             safe_title = "".join(c for c in title if c.isalnum() or c in (' ', '-', '_')).rstrip()
             
             # Download
@@ -40,13 +54,14 @@ def download_snippet(url, duration_sec):
             raise Exception("Downloaded file is empty")
         
         # Create output filename
-        output_file = os.path.join(temp_dir, f"{safe_title}_{duration_sec}s.mp3")
+        output_file = os.path.join(temp_dir, f"{safe_title}_{start_sec}-{end_sec}s.mp3")
         
-        # Use ffmpeg to trim (this is the key fix!)
+        # Use ffmpeg to trim with start and end times
         cmd = [
             'ffmpeg',
             '-i', input_file,          # Input file
-            '-t', str(duration_sec),   # Duration to keep
+            '-ss', str(start_sec),     # Start time
+            '-to', str(end_sec),       # End time
             '-acodec', 'libmp3lame',   # MP3 codec
             '-q:a', '2',               # Good quality
             '-y',                      # Overwrite output
@@ -63,7 +78,7 @@ def download_snippet(url, duration_sec):
         if not os.path.exists(output_file) or os.path.getsize(output_file) == 0:
             raise Exception("Trimmed file is empty")
         
-        return output_file, f"{safe_title}_{duration_sec}s.mp3"
+        return output_file, f"{safe_title}_{start_sec}-{end_sec}s.mp3", duration_full
         
     except Exception as e:
         # Clean up on error
@@ -76,7 +91,7 @@ def download_snippet(url, duration_sec):
 with gr.Blocks(title="SoundCloud Snippet", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🎵 SoundCloud Snippet Downloader
-    Download the first N seconds of any public SoundCloud track
+    Download any segment of a public SoundCloud track
     """)
     
     with gr.Row():
@@ -88,13 +103,50 @@ with gr.Blocks(title="SoundCloud Snippet", theme=gr.themes.Soft()) as demo:
         )
     
     with gr.Row():
-        duration = gr.Slider(
-            minimum=5,
-            maximum=400,
-            value=30,
-            step=5,
-            label="Duration (seconds)"
-        )
+        with gr.Column(scale=1):
+            start_slider = gr.Slider(
+                minimum=0,
+                maximum=600,
+                value=0,
+                step=1,
+                label="Start Time (seconds)"
+            )
+            start_number = gr.Number(
+                value=0,
+                label="Start (seconds)",
+                precision=0,
+                minimum=0,
+                maximum=600
+            )
+        
+        with gr.Column(scale=1):
+            end_slider = gr.Slider(
+                minimum=1,
+                maximum=600,
+                value=30,
+                step=1,
+                label="End Time (seconds)"
+            )
+            end_number = gr.Number(
+                value=30,
+                label="End (seconds)",
+                precision=0,
+                minimum=1,
+                maximum=600
+            )
+        
+        with gr.Column(scale=1):
+            duration_display = gr.Textbox(
+                label="Segment Duration",
+                value="30 seconds",
+                interactive=False
+            )
+            max_duration = gr.Textbox(
+                label="Track Duration",
+                value="Unknown",
+                interactive=False,
+                visible=False
+            )
     
     with gr.Row():
         download_btn = gr.Button("Download Snippet", variant="primary")
@@ -103,27 +155,90 @@ with gr.Blocks(title="SoundCloud Snippet", theme=gr.themes.Soft()) as demo:
         audio_player = gr.Audio(label="Preview", type="filepath")
         download_file = gr.DownloadButton("Save MP3", visible=False)
     
-    # Store file path
+    # Store file path and track duration
     file_path = gr.State()
+    track_duration = gr.State(0)
+    
+    # Sync sliders and number inputs
+    def sync_start(start_val):
+        return start_val, start_val
+    
+    def sync_end(end_val):
+        return end_val, end_val
+    
+    start_slider.change(
+        sync_start,
+        inputs=[start_slider],
+        outputs=[start_number, start_slider]
+    )
+    
+    start_number.change(
+        sync_start,
+        inputs=[start_number],
+        outputs=[start_slider, start_number]
+    )
+    
+    end_slider.change(
+        sync_end,
+        inputs=[end_slider],
+        outputs=[end_number, end_slider]
+    )
+    
+    end_number.change(
+        sync_end,
+        inputs=[end_number],
+        outputs=[end_slider, end_number]
+    )
+    
+    # Update duration display
+    def update_duration(start, end):
+        duration = end - start
+        if duration <= 0:
+            return "Invalid (start must be before end)", gr.update(visible=False)
+        return f"{duration} seconds", gr.update(visible=True)
+    
+    start_slider.change(
+        update_duration,
+        inputs=[start_slider, end_slider],
+        outputs=[duration_display, download_btn]
+    )
+    
+    end_slider.change(
+        update_duration,
+        inputs=[start_slider, end_slider],
+        outputs=[duration_display, download_btn]
+    )
     
-    def process_download(url, duration):
+    def process_download(url, start, end):
         if not url or 'soundcloud.com' not in url.lower():
             raise gr.Error("Please enter a valid SoundCloud URL")
         
+        if start >= end:
+            raise gr.Error("Start time must be before end time")
+        
         try:
-            filepath, filename = download_snippet(url, duration)
+            filepath, filename, full_duration = download_snippet(url, start, end)
+            
+            # Update max duration display if we have it
+            max_dur_update = gr.update(
+                value=f"{full_duration} seconds" if full_duration > 0 else "Unknown",
+                visible=True
+            )
+            
             return {
                 audio_player: filepath,
                 download_file: gr.DownloadButton(visible=True),
-                file_path: filepath
+                file_path: filepath,
+                max_duration: max_dur_update,
+                track_duration: full_duration
             }
         except Exception as e:
             raise gr.Error(f"Download failed: {str(e)}")
     
     download_btn.click(
         process_download,
-        inputs=[url, duration],
-        outputs=[audio_player, download_file, file_path]
+        inputs=[url, start_slider, end_slider],
+        outputs=[audio_player, download_file, file_path, max_duration, track_duration]
     )
     
     download_file.click(
@@ -131,6 +246,25 @@ with gr.Blocks(title="SoundCloud Snippet", theme=gr.themes.Soft()) as demo:
         inputs=[file_path],
         outputs=None
     )
+    
+    # Auto-adjust end slider when track duration is known
+    def adjust_sliders(full_duration):
+        if full_duration and full_duration > 0:
+            return (
+                gr.update(maximum=min(600, full_duration)),
+                gr.update(maximum=min(600, full_duration), value=min(30, full_duration)),
+                gr.update(maximum=min(600, full_duration)),
+                gr.update(maximum=min(600, full_duration), value=min(30, full_duration))
+            )
+        return (
+            gr.update(maximum=600),
+            gr.update(maximum=600),
+            gr.update(maximum=600),
+            gr.update(maximum=600)
+        )
+    
+    # This would need to be triggered after we get track duration
+    # For simplicity, we'll update when the download completes
 
 if __name__ == "__main__":
     demo.launch()