Update app.py

app.py

@@ -8,8 +8,9 @@ import tempfile
 from pathlib import Path
 import sys
 import asyncio
+import base64  # Hinzugefügt, um base64 zu importieren
 
-# Replace with your actual client ID and client secret
+# Ersetzen Sie dies durch Ihre tatsächliche Client-ID und Client-Secret
 client_id = os.environ.get('SOUNDCLOUD_CLIENT_ID')
 client_secret = os.environ.get('SOUNDCLOUD_CLIENT_SECRET')
 token = os.environ.get('TOKEN')
@@ -24,22 +25,21 @@ def get_soundcloud_access_token(client_id, client_secret):
             'grant_type': 'client_credentials'
         }
         response = requests.post('https://api.soundcloud.com/oauth2/token', headers=auth_headers, data=data)
-        if response.status_code == 200:
-            token_data = response.json()
-            return token_data['access_token']
-        else:
-            raise Exception(f"Failed to obtain access token: {response.text}")
-    except Exception as e:
-        return f"Error obtaining access token: {str(e)}"
+        response.raise_for_status()  # Verwenden Sie raise_for_status, um Fehler zu behandeln
+        token_data = response.json()
+        return token_data['access_token']
+    except requests.RequestException as e:
+        return f"Fehler beim Abrufen des Zugriffstokens: {str(e)}"
 
 def download_audio(streaming_url, output_path, headers):
     try:
         response = requests.get(streaming_url, headers=headers, stream=True)
+        response.raise_for_status()  # Verwenden Sie raise_for_status, um Fehler zu behandeln
         with open(output_path, 'wb') as f:
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
-    except Exception as e:
-        raise Exception(f"Error downloading audio: {str(e)}")
+    except requests.RequestException as e:
+        raise Exception(f"Fehler beim Herunterladen des Audios: {str(e)}")
 
 async def identify_track(shazam, audio_chunk, temp_dir):
     try:
@@ -52,58 +52,56 @@ async def identify_track(shazam, audio_chunk, temp_dir):
                 'title': track_data['title'],
                 'subtitle': track_data['subtitle']
             }
-        else:
-            return None
+        return None
     except Exception as e:
-        return f"Error identifying track: {str(e)}"
+        return f"Fehler bei der Identifizierung des Tracks: {str(e)}"
 
 async def process_dj_set(track_url, progress=gr.Progress()):
-    temp_dir = "/tmp"
+    temp_dir = tempfile.gettempdir()  # Verwenden Sie tempfile für temporäre Verzeichnisse
     output_path = os.path.join(temp_dir, 'track.wav')
     tracklist_path = os.path.join(temp_dir, 'tracklist.txt')
     status_messages = []
 
-    # Check environment variables
+    # Überprüfen Sie die Umgebungsvariablen
     if not client_id or not client_secret or not token:
-        return "", "", "Environment variables not set."
+        return "", "", "Umgebungsvariablen sind nicht gesetzt."
 
-    # Get access token
+    # Zugriffstoken abrufen
     access_token = get_soundcloud_access_token(client_id, client_secret)
-    if isinstance(access_token, str) and access_token.startswith("Error"):
+    if isinstance(access_token, str) and access_token.startswith("Fehler"):
         return "", "", access_token
 
     headers = {
         'Authorization': f'Bearer {access_token}'
     }
 
-    # Resolve track URL
+    # Track-URL auflösen
     try:
         resolve_response = requests.get(f'https://api.soundcloud.com/resolve.json?url={track_url}', headers=headers)
-        if resolve_response.status_code != 200:
-            return "", "", f"Failed to resolve track URL: {resolve_response.text}"
+        resolve_response.raise_for_status()  # Verwenden Sie raise_for_status, um Fehler zu behandeln
         track_data = resolve_response.json()
         streaming_url = track_data['stream_url']
-        status_messages.append("Track URL resolved successfully.")
-    except Exception as e:
-        return "", "", f"Error resolving track URL: {str(e)}"
+        status_messages.append("Track-URL erfolgreich aufgelöst.")
+    except requests.RequestException as e:
+        return "", "", f"Fehler beim Auflösen der Track-URL: {str(e)}"
 
-    # Download audio
+    # Audio herunterladen
     try:
         download_audio(streaming_url, output_path, headers)
-        status_messages.append("Audio downloaded successfully.")
+        status_messages.append("Audio erfolgreich heruntergeladen.")
     except Exception as e:
-        return "", "", f"Error downloading audio: {str(e)}"
+        return "", "", f"Fehler beim Herunterladen des Audios: {str(e)}"
 
-    # Load audio
+    # Audio laden
     try:
         audio = AudioSegment.from_wav(output_path)
-        status_messages.append("Audio loaded successfully.")
+        status_messages.append("Audio erfolgreich geladen.")
     except Exception as e:
-        return "", "", f"Error loading audio: {str(e)}"
+        return "", "", f"Fehler beim Laden des Audios: {str(e)}"
 
-    # Split audio into chunks
-    chunk_duration = 30000  # 30 seconds
-    overlap = 10000  # 10 seconds
+    # Audio in Chunks aufteilen
+    chunk_duration = 30000  # 30 Sekunden
+    overlap = 10000  # 10 Sekunden
     chunks = []
     start = 0
     while start + chunk_duration < len(audio):
@@ -112,33 +110,33 @@ async def process_dj_set(track_url, progress=gr.Progress()):
         chunks.append((start, chunk))
         start += chunk_duration - overlap
 
-    # Initialize Shazam
+    # Shazam initialisieren
     shazam = shazamio.Shazam()
 
-    # Identify tracks
+    # Tracks identifizieren
     tracklist = []
     for start_time, chunk in chunks:
         progress(0.1)
         track_info = await identify_track(shazam, chunk, temp_dir)
         if isinstance(track_info, dict):
             timestamp = time.strftime("%M:%S", time.gmtime(start_time / 1000))
-            tracklist.append(f"{timestamp} - {track_info['title']} by {track_info['subtitle']}")
+            tracklist.append(f"{timestamp} - {track_info['title']} von {track_info['subtitle']}")
         elif isinstance(track_info, str):
             status_messages.append(track_info)
 
-    # Prepare tracklist output
+    # Tracklist-Ausgabe vorbereiten
     tracklist_output = "\n".join(tracklist)
     with open(tracklist_path, 'w') as f:
         f.write(tracklist_output)
 
-    # Clean up temporary directory
+    # Temporäres Verzeichnis bereinigen
     import shutil
     shutil.rmtree(temp_dir)
 
-    # Prepare status message
+    # Statusnachricht vorbereiten
     status_message = "\n".join(status_messages)
     if not tracklist:
-        status_message += "\nNo tracks identified."
+        status_message += "\nKeine Tracks identifiziert."
 
     return tracklist_output, tracklist_path, status_message
 
@@ -158,13 +156,13 @@ with gr.Blocks(css=css) as demo:
                 label="SoundCloud DJ Set URL",
                 show_label=False,
                 max_lines=1,
-                placeholder="Enter SoundCloud DJ set URL",
+                placeholder="Geben Sie die SoundCloud DJ-Set-URL ein",
                 container=False,
             )
-            run_button = gr.Button("Process", scale=0, variant="primary")
-        result = gr.Textbox(label="Tracklist", show_label=False)
-        with gr.Accordion("Download Tracklist", open=False):
-            download_button = gr.File(label="Download")
+            run_button = gr.Button("Verarbeiten", scale=0, variant="primary")
+        result = gr.Textbox(label="Trackliste", show_label=False)
+        with gr.Accordion("Trackliste herunterladen", open=False):
+            download_button = gr.File(label="Herunterladen")
         gr.Examples(examples=["https://soundcloud.com/your-track-url"], inputs=[track_url])
 
     run_button.click(process_dj_set, inputs=track_url, outputs=[result, download_button, status_text])