done

app.py

@@ -1,115 +1,156 @@
 import gradio as gr
-import subprocess
-import requests
-import re
-import traceback
-
-# Regular expression to validate YouTube URLs
-YOUTUBE_URL_PATTERN = re.compile(
-    r'(https?://)?(www\.)?(youtube\.com|youtu\.?be)/.+'
-)
-
-def test_network():
+import librosa
+import numpy as np
+import torch
+from diffusers import StableDiffusionPipeline
+import os
+import gradio as gr
+import sys
+
+print(f"Gradio version: {gr.__version__}")
+print(f"Gradio location: {gr.__file__}")
+print(f"Python executable: {sys.executable}")
+
+# Ensure that the script uses CUDA if available
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device: {device}")
+
+# Load the Stable Diffusion model
+model_id = "runwayml/stable-diffusion-v1-5"  # Updated model ID for better accessibility
+try:
+    stable_diffusion = StableDiffusionPipeline.from_pretrained(
+        model_id,
+        torch_dtype=torch.float16 if device == "cuda" else torch.float32
+    ).to(device)
+except Exception as e:
+    print(f"Error loading the model: {e}")
+    print("Ensure you have the correct model ID and access rights.")
+    exit(1)
+
+def describe_audio(audio_path):
+    """
+    Generate a textual description based on audio features.
+
+    Parameters:
+        audio_path (str): Path to the audio file.
+
+    Returns:
+        str: Generated description.
+    """
     try:
-        response = requests.get("https://www.youtube.com", timeout=10)
-        if response.status_code == 200:
-            return "Successfully connected to YouTube."
+        # Load the audio file
+        y, sr = librosa.load(audio_path, sr=None)
+
+        # Extract Mel Spectrogram
+        S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
+        db_spec = librosa.power_to_db(S, ref=np.max)
+
+        # Calculate average amplitude and frequency
+        avg_amplitude = np.mean(db_spec)
+        spectral_centroids = librosa.feature.spectral_centroid(y=y, sr=sr)
+        avg_frequency = np.mean(spectral_centroids)
+
+        # Generate description based on amplitude
+        if avg_amplitude < -40:
+            amplitude_desc = "a calm and serene landscape with gentle waves"
+        elif avg_amplitude < -20:
+            amplitude_desc = "a vibrant forest with rustling leaves"
+        else:
+            amplitude_desc = "a thunderstorm with dark clouds and lightning"
+
+        # Generate description based on frequency
+        if avg_frequency < 2000:
+            frequency_desc = "under soft, ambient light"
+        elif avg_frequency < 4000:
+            frequency_desc = "with vivid and lively colors"
         else:
-            return f"Failed to connect to YouTube. Status code: {response.status_code}"
+            frequency_desc = "in a surreal and dynamic setting"
+
+        # Combine descriptions
+        description = f"{amplitude_desc} {frequency_desc}"
+        return description
     except Exception as e:
-        return f"Exception occurred: {e}"
-
-def test_youtube_transcript(link):
-    debug_info = ""
-    transcript_text = ""
-    thumbnail_url = None
-
-    # Validate YouTube URL
-    if not YOUTUBE_URL_PATTERN.match(link):
-        return "", "Invalid YouTube URL provided.", None
-
-    # Add network test result to debug info
-    test_result = test_network()
-    debug_info += f"Network test result: {test_result}\n"
-
-    # Include package versions
-    import gradio
-    import yt_dlp
-    import requests
-    debug_info += f"Package versions:\n"
-    debug_info += f"gradio: {gradio.__version__}\n"
-    debug_info += f"yt-dlp: {yt_dlp.version.__version__}\n"
-    debug_info += f"requests: {requests.__version__}\n"
+        print(f"Error processing audio: {e}")
+        return "an abstract artistic scene"
+
+def generate_image(description):
+    """
+    Generate an image using the Stable Diffusion model based on the description.
+
+    Parameters:
+        description (str): Textual description for image generation.
 
+    Returns:
+        PIL.Image: Generated image.
+    """
     try:
-        # Use yt-dlp as a subprocess to download subtitles
-        command = [
-            'yt-dlp',
-            '--skip-download',
-            '--write-subs',
-            '--sub-lang', 'en',
-            '--sub-format', 'vtt',
-            '--output', '%(id)s.%(ext)s',
-            link
-        ]
-
-        result = subprocess.run(command, capture_output=True, text=True)
-
-        if result.returncode != 0:
-            transcript_text = "Failed to download subtitles using yt-dlp."
-            debug_info += f"yt-dlp error: {result.stderr}\n"
-            return transcript_text, debug_info, thumbnail_url
-
-        # Extract video ID from URL
-        video_id_match = re.search(r'v=([A-Za-z0-9_-]{11})', link)
-        if video_id_match:
-            video_id = video_id_match.group(1)
-            debug_info += f"Video ID: {video_id}\n"
-            thumbnail_url = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
-            debug_info += f"Thumbnail URL: {thumbnail_url}\n"
+        if device == "cuda":
+            with torch.autocast("cuda"):
+                image = stable_diffusion(description).images[0]
         else:
-            video_id = "unknown"
-            debug_info += "Could not extract Video ID.\n"
-
-        # Read the downloaded subtitle file
-        subtitle_file = f"{video_id}.en.vtt"
-        try:
-            with open(subtitle_file, 'r', encoding='utf-8') as f:
-                transcript_text = f.read()
-
-            # Process the VTT file to extract plain text
-            transcript_text = re.sub(r'WEBVTT\n\n', '', transcript_text)
-            transcript_text = re.sub(r'\d+\n', '', transcript_text)
-            transcript_text = re.sub(r'\d{2}:\d{2}:\d{2}\.\d{3} --> \d{2}:\d{2}:\d{2}\.\d{3}\n', '', transcript_text)
-            transcript_text = transcript_text.strip()
-
-            debug_info += "Transcript fetched using yt-dlp subprocess.\n"
-        except FileNotFoundError:
-            transcript_text = "Subtitle file not found."
-            debug_info += "Subtitle file was not found after yt-dlp execution.\n"
-        except Exception as e:
-            transcript_text = f"An error occurred while reading subtitles: {e}"
-            debug_info += f"Error reading subtitles: {e}\n"
-            debug_info += traceback.format_exc()
+            image = stable_diffusion(description).images[0]
+        return image
     except Exception as e:
-        transcript_text = f"An error occurred with yt-dlp subprocess: {e}"
-        debug_info += f"Error with yt-dlp subprocess: {e}\n"
-        debug_info += traceback.format_exc()
-
-    return transcript_text, debug_info, thumbnail_url
-
-# Gradio interface
-demo = gr.Interface(
-    fn=test_youtube_transcript,
-    inputs=gr.Textbox(label="YouTube Video URL", placeholder="Enter YouTube video URL here"),
-    outputs=[
-        gr.Textbox(label="Transcript", lines=20, interactive=False),
-        gr.Textbox(label="Debug Information", lines=20, interactive=False),
-        gr.Image(label="Thumbnail")
-    ],
-    title="YouTube Transcript Fetcher",
-    description="Enter a YouTube video link to fetch the transcript and detailed debug information."
+        print(f"Error generating image: {e}")
+        return None
+
+def audio_to_image(audio_file):
+    """
+    Convert an audio file to an artistic image.
+
+    Parameters:
+        audio_file (str): Path to the uploaded audio file.
+
+    Returns:
+        PIL.Image or str: Generated image or error message.
+    """
+    if audio_file is None:
+        return "No audio file provided."
+
+    description = describe_audio(audio_file)
+    print(f"Generated Description: {description}")
+
+    image = generate_image(description)
+    if image is not None:
+        return image
+    else:
+        return "Failed to generate image."
+
+# Gradio Interface
+title = "🎵 Audio to Artistic Image Converter 🎨"
+description_text = """
+Upload an audio file, and this app will generate an artistic image based on the sound's characteristics.
+"""
+
+# Define example paths
+example_paths = [
+    "example_audio/calm_ocean.wav",
+    "example_audio/rustling_leaves.wav",
+    "example_audio/thunderstorm.wav",
+]
+
+# Verify example files exist
+valid_examples = []
+for path in example_paths:
+    if os.path.isfile(path):
+        valid_examples.append([path])
+    else:
+        print(f"Example file not found: {path}")
+
+if not os.path.exists("example_audio"):
+    os.makedirs("example_audio")
+    print("Please add some example audio files in the 'example_audio' directory.")
+
+interface = gr.Interface(
+    fn=audio_to_image,
+    inputs=gr.Audio(source="upload", type="filepath"),
+    outputs=gr.Image(type="pil"),
+    title=title,
+    description=description_text,
+    examples=valid_examples if valid_examples else None,
+    allow_flagging="never",
+    theme="default"
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    interface.launch()

requirements.txt

@@ -1,3 +1,10 @@
-gradio==4.44.1
 yt-dlp==2023.10.7
 requests==2.32.3
+accelerate
+gradio>=4.44.1
+librosa
+numpy
+torch
+diffusers
+accelerate
+psutil