Copied to github

.gitignore

@@ -0,0 +1,4 @@
+.env
+*.pyc
+__pycache__/
+.vercel

Dockerfile

@@ -0,0 +1,20 @@
+# Use the official Python image from the Docker Hub
+FROM python:3.9-alpine
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements.txt file to the container at /app
+COPY requirements.txt .
+
+# Install any dependencies specified in requirements.txt
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# Copy the current directory contents into the container at /app
+COPY . .
+
+# Expose port 5000 for the Flask app
+EXPOSE 5100
+
+# Command to run the Flask app
+CMD ["flask", "run", "--host=0.0.0.0", "--port=5100"]

Procfile

@@ -0,0 +1 @@
+ web: gunicorn app:app

app.py

@@ -0,0 +1,254 @@
+import os
+import tempfile
+import logging
+import re
+import zipfile
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.mime.base import MIMEBase
+from email import encoders
+from dotenv import load_dotenv
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import multiprocessing
+from flask import Flask, render_template, request, jsonify
+from googleapiclient.discovery import build
+import yt_dlp
+from pydub import AudioSegment
+
+app = Flask(__name__, static_folder='static')
+
+
+# Load API key and email credentials from .env file
+load_dotenv()
+api_key = os.getenv('YOUTUBE_API_KEY')
+sender_email = os.getenv('SENDER_EMAIL')
+email_password = os.getenv('EMAIL_PASSWORD')
+
+# Validate environment variables
+if not all([api_key, sender_email, email_password]):
+    raise ValueError("Missing environment variables. Please check your .env file.")
+
+# Determine the number of CPU cores available
+num_cores = multiprocessing.cpu_count()
+
+# Function to validate email
+def is_valid_email(email):
+    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
+    return re.match(pattern, email) is not None
+
+# Function to get YouTube links
+def get_youtube_links(api_key, query, max_results=20):
+    try:
+        youtube = build('youtube', 'v3', developerKey=api_key)
+        search_response = youtube.search().list(
+            q=query,
+            part='snippet',
+            type='video',
+            maxResults=max_results
+        ).execute()
+
+        videos = []
+        for item in search_response['items']:
+            video_id = item['id']['videoId']
+            video_title = item['snippet']['title']
+            video_url = f"https://www.youtube.com/watch?v={video_id}"
+            videos.append((video_title, video_url))
+
+        return videos
+    except Exception as e:
+        logging.error(f"Failed to fetch YouTube links: {e}")
+        return []
+
+# Function to download audio from YouTube
+def download_single_audio(url, index, download_path):
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'outtmpl': f'{download_path}/song_{index}_%(title)s.%(ext)s',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '192',
+        }],
+        'retries': 10,
+        'fragment_retries': 10,
+    }
+
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+        downloaded_files = [f for f in os.listdir(download_path) if f.startswith(f"song_{index}_") and f.endswith(".mp3")]
+        if downloaded_files:
+            return os.path.join(download_path, downloaded_files[0])
+        else:
+            logging.error(f"Downloaded file not found for {url}")
+            return None
+    except Exception as e:
+        logging.error(f"Error downloading audio: {e}")
+        return None
+
+# Function to download all audio files in parallel
+def download_all_audio(video_urls, download_path):
+    downloaded_files = []
+    with ThreadPoolExecutor(max_workers=num_cores) as executor:
+        futures = {
+            executor.submit(download_single_audio, url, index, download_path): index
+            for index, url in enumerate(video_urls, start=1)
+        }
+
+        for future in as_completed(futures):
+            try:
+                mp3_file = future.result()
+                if mp3_file:
+                    downloaded_files.append(mp3_file)
+            except Exception as e:
+                logging.error(f"Error occurred: {e}")
+
+    return downloaded_files
+
+# Function to create a mashup from audio files
+def create_mashup(audio_files, output_file, trim_duration):
+    mashup = AudioSegment.silent(duration=0)
+    total_trim_duration_per_file = trim_duration * 1000  # Convert to milliseconds
+
+    for file in audio_files:
+        try:
+            audio = AudioSegment.from_file(file)
+            if len(audio) < total_trim_duration_per_file:
+                logging.warning(f"Audio file {file} is shorter than trim duration. Using full length.")
+                part = audio
+            else:
+                part = audio[:total_trim_duration_per_file]
+            mashup += part
+        except Exception as e:
+            logging.error(f"Error processing file {file}: {e}")
+
+    if len(mashup) == 0:
+        logging.error("No audio files were successfully processed.")
+        return None
+
+    expected_mashup_duration = total_trim_duration_per_file * len(audio_files)
+    if len(mashup) < expected_mashup_duration:
+        logging.warning(f"Mashup duration ({len(mashup)}ms) is less than expected ({expected_mashup_duration}ms).")
+    else:
+        mashup = mashup[:expected_mashup_duration]
+
+    mashup.export(output_file, format="mp3", bitrate="128k")
+    return output_file
+
+def create_zip_file(file_path, zip_path):
+    with zipfile.ZipFile(zip_path, 'w') as zipf:
+        zipf.write(file_path, os.path.basename(file_path))
+    return zip_path
+
+# Function to send email
+def send_email(sender_email, receiver_email, subject, body, attachment_path, password):
+    try:
+        msg = MIMEMultipart()
+        msg['From'] = sender_email
+        msg['To'] = receiver_email
+        msg['Subject'] = subject
+
+        msg.attach(MIMEText(body, 'plain'))
+
+        with open(attachment_path, 'rb') as attachment:
+            part = MIMEBase('application', 'zip')
+            part.set_payload(attachment.read())
+            encoders.encode_base64(part)
+            part.add_header('Content-Disposition', f"attachment; filename= {os.path.basename(attachment_path)}")
+            msg.attach(part)
+
+        server = smtplib.SMTP('smtp.gmail.com', 587)
+        server.starttls()
+        server.login(sender_email, password)
+        text = msg.as_string()
+        server.sendmail(sender_email, receiver_email, text)
+        server.quit()
+
+        logging.info("Email sent successfully!")
+        return True
+    except Exception as e:
+        logging.error(f"Failed to send email: {e}")
+        return False
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/create_mashup', methods=['POST'])
+def create_mashup_route():
+    try:
+        # Log incoming request data
+        logging.info(f"Received create_mashup request: {request.form}")
+
+        # Validate and extract form data
+        singer_name = request.form.get('singer_name')
+        num_videos = request.form.get('num_videos')
+        trim_duration = request.form.get('trim_duration')
+        receiver_email = request.form.get('receiver_email')
+
+        # Validate required fields
+        if not all([singer_name, num_videos, trim_duration, receiver_email]):
+            missing_fields = [field for field in ['singer_name', 'num_videos', 'trim_duration', 'receiver_email'] if not request.form.get(field)]
+            return jsonify({'status': 'error', 'message': f'Missing required fields: {", ".join(missing_fields)}'})
+
+        # Validate and convert numeric fields
+        try:
+            num_videos = max(int(num_videos), 10)
+            trim_duration = max(int(trim_duration), 20)
+        except ValueError:
+            return jsonify({'status': 'error', 'message': 'Invalid numeric values for num_videos or trim_duration'})
+
+        # Validate email
+        if not is_valid_email(receiver_email):
+            return jsonify({'status': 'error', 'message': 'Please enter a valid email address.'})
+
+        # Fetch YouTube links
+        logging.info(f"Fetching YouTube links for {singer_name}")
+        videos = get_youtube_links(api_key, singer_name, max_results=num_videos)
+
+        if not videos:
+            return jsonify({'status': 'error', 'message': f'No videos found for {singer_name}. Please try a different singer name.'})
+
+        # Create temporary directory
+        with tempfile.TemporaryDirectory() as download_path:
+            logging.info(f"Created temporary directory: {download_path}")
+
+            # Download audio files
+            video_urls = [url for _, url in videos]
+            logging.info(f"Downloading {len(video_urls)} audio files")
+            audio_files = download_all_audio(video_urls, download_path)
+
+            if not audio_files:
+                return jsonify({'status': 'error', 'message': 'Failed to download audio files. Please try again.'})
+
+            # Create mashup
+            logging.info("Creating mashup")
+            output_file = os.path.join(download_path, "mashup.mp3")
+            mashup_file = create_mashup(audio_files, output_file, trim_duration)
+
+            if not mashup_file:
+                return jsonify({'status': 'error', 'message': 'Failed to create mashup. Please try again.'})
+
+            # Create zip file
+            zip_file = os.path.join(download_path, "mashup.zip")
+            create_zip_file(mashup_file, zip_file)
+
+            # Send email
+            logging.info(f"Sending email to {receiver_email}")
+            subject = f"Your {singer_name} YouTube Mashup"
+            body = f"Please find attached your custom YouTube mashup of {singer_name} songs. Duration: {trim_duration * len(audio_files)} seconds."
+            email_sent = send_email(sender_email, receiver_email, subject, body, zip_file, email_password)
+
+            if email_sent:
+                return jsonify({'status': 'success', 'message': 'Mashup created and sent successfully! Check your email.'})
+            else:
+                return jsonify({'status': 'error', 'message': 'Mashup created but failed to send email. Please try again.'})
+
+    except Exception as e:
+        logging.error(f"Unexpected error in create_mashup_route: {str(e)}", exc_info=True)
+        return jsonify({'status': 'error', 'message': f'An unexpected error occurred: {str(e)}'})
+
+if __name__ == '__main__':
+    port = int(os.environ.get('PORT', 5000))
+    app.run(host='0.0.0.0', port=port)

docker-compose.yaml

@@ -0,0 +1,8 @@
+version: "3.8"
+services:
+  flask-app:
+    build: .
+    ports:
+      - "5100:5100"
+    env_file:
+      - .env

render.yaml

@@ -0,0 +1,10 @@
+services:
+  - type: web
+    name: youtube-mashup-creator
+    buildCommand: pip install -r requirements.txt
+    startCommand: gunicorn app:app
+    envVars:
+      - key: PYTHON_VERSION
+        value: 3.8.0
+    packages:
+      - ffmpeg

requirements.txt

@@ -0,0 +1,8 @@
+Flask==2.2.5
+Werkzeug==2.2.3
+flask-cors==3.0.10
+python-dotenv==1.0.0
+google-api-python-client==2.86.0
+yt-dlp==2023.3.4
+pydub==0.25.1
+gunicorn==20.1.0

templates/index.html

@@ -0,0 +1,307 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>YouTube Mashup Creator</title>
+        <link
+            href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css"
+            rel="stylesheet"
+        />
+        <style>
+            :root {
+                --primary-color: #4a90e2;
+                --secondary-color: #f39c12;
+                --background-color: #f4f4f4;
+                --text-color: #333;
+            }
+
+            body {
+                font-family: "Arial", sans-serif;
+                line-height: 1.6;
+                margin: 0;
+                padding: 0;
+                background-color: var(--background-color);
+                color: var(--text-color);
+            }
+
+            .container {
+                max-width: 800px;
+                margin: 2rem auto;
+                padding: 2rem;
+                background-color: #fff;
+                border-radius: 10px;
+                box-shadow: 0 0 20px rgba(0, 0, 0, 0.1);
+            }
+
+            h1 {
+                color: var(--primary-color);
+                text-align: center;
+                margin-bottom: 2rem;
+                font-size: 2.5rem;
+            }
+
+            .form-group {
+                margin-bottom: 1.5rem;
+            }
+
+            label {
+                display: block;
+                margin-bottom: 0.5rem;
+                font-weight: bold;
+            }
+
+            input[type="text"],
+            input[type="number"],
+            input[type="email"] {
+                width: 100%;
+                padding: 0.8rem;
+                border: 1px solid #ddd;
+                border-radius: 4px;
+                font-size: 1rem;
+            }
+
+            button {
+                display: block;
+                width: 100%;
+                padding: 1rem;
+                background-color: var(--primary-color);
+                color: #fff;
+                border: none;
+                border-radius: 4px;
+                cursor: pointer;
+                font-size: 1.1rem;
+                transition: background-color 0.3s ease;
+            }
+
+            button:hover {
+                background-color: #3570b8;
+            }
+
+            .loader {
+                border: 5px solid #f3f3f3;
+                border-top: 5px solid var(--secondary-color);
+                border-radius: 50%;
+                width: 50px;
+                height: 50px;
+                animation: spin 1s linear infinite;
+                margin: 20px auto;
+            }
+
+            @keyframes spin {
+                0% {
+                    transform: rotate(0deg);
+                }
+                100% {
+                    transform: rotate(360deg);
+                }
+            }
+
+            .message {
+                margin-top: 1.5rem;
+                padding: 1rem;
+                border-radius: 4px;
+                text-align: center;
+                font-weight: bold;
+            }
+
+            .message.success {
+                background-color: #d4edda;
+                color: #155724;
+            }
+
+            .message.error {
+                background-color: #f8d7da;
+                color: #721c24;
+            }
+
+            .info-icon {
+                color: var(--primary-color);
+                margin-left: 0.5rem;
+                cursor: help;
+            }
+
+            .tooltip {
+                position: relative;
+                display: inline-block;
+            }
+
+            .tooltip .tooltiptext {
+                visibility: hidden;
+                width: 200px;
+                background-color: #555;
+                color: #fff;
+                text-align: center;
+                border-radius: 6px;
+                padding: 5px;
+                position: absolute;
+                z-index: 1;
+                bottom: 125%;
+                left: 50%;
+                margin-left: -100px;
+                opacity: 0;
+                transition: opacity 0.3s;
+            }
+
+            .tooltip:hover .tooltiptext {
+                visibility: visible;
+                opacity: 1;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1><i class="fas fa-music"></i> YouTube Mashup Creator</h1>
+            <form id="mashupForm">
+                <div class="form-group">
+                    <label for="singer_name">Singer name:</label>
+                    <input
+                        type="text"
+                        id="singer_name"
+                        name="singer_name"
+                        required
+                    />
+                </div>
+
+                <div class="form-group">
+                    <label for="num_videos">Number of videos (10-30):</label>
+                    <input
+                        type="number"
+                        id="num_videos"
+                        name="num_videos"
+                        min="10"
+                        max="30"
+                        value="10"
+                        required
+                    />
+                    <span class="tooltip">
+                        <i class="fas fa-info-circle info-icon"></i>
+                        <span class="tooltiptext"
+                            >Choose between 10 and 30 videos for your
+                            mashup.</span
+                        >
+                    </span>
+                </div>
+
+                <div class="form-group">
+                    <label for="trim_duration"
+                        >Trim duration for each video (20-500 seconds):</label
+                    >
+                    <input
+                        type="number"
+                        id="trim_duration"
+                        name="trim_duration"
+                        min="20"
+                        max="500"
+                        value="20"
+                        required
+                    />
+                    <span class="tooltip">
+                        <i class="fas fa-info-circle info-icon"></i>
+                        <span class="tooltiptext"
+                            >Choose a trim duration between 20 and 500 seconds
+                            for each video clip.</span
+                        >
+                    </span>
+                </div>
+
+                <div class="form-group">
+                    <label for="receiver_email">Your email address:</label>
+                    <input
+                        type="email"
+                        id="receiver_email"
+                        name="receiver_email"
+                        required
+                    />
+                </div>
+
+                <button type="submit">
+                    <i class="fas fa-magic"></i> Create and Send Mashup
+                </button>
+            </form>
+
+            <div id="loader" class="loader" style="display: none"></div>
+
+            <div id="message" class="message" style="display: none"></div>
+        </div>
+
+        <script>
+            document.addEventListener("DOMContentLoaded", function () {
+                const form = document.getElementById("mashupForm");
+                const loader = document.getElementById("loader");
+                const message = document.getElementById("message");
+
+                function validateEmail(email) {
+                    const re =
+                        /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+                    return re.test(String(email).toLowerCase());
+                }
+
+                form.addEventListener("submit", function (e) {
+                    e.preventDefault();
+
+                    const email = form.querySelector("#receiver_email").value;
+                    if (!validateEmail(email)) {
+                        message.textContent =
+                            "Please enter a valid email address.";
+                        message.className = "message error";
+                        message.style.display = "block";
+                        return;
+                    }
+
+                    // Show loader
+                    loader.style.display = "block";
+                    message.style.display = "none";
+
+                    // Disable submit button
+                    form.querySelector('button[type="submit"]').disabled = true;
+
+                    // Create FormData object
+                    const formData = new FormData(form);
+
+                    // Send AJAX request
+                    fetch("/create_mashup", {
+                        method: "POST",
+                        body: formData,
+                    })
+                        .then((response) => response.json())
+                        .then((data) => {
+                            // Hide loader
+                            loader.style.display = "none";
+
+                            // Show message
+                            message.textContent = data.message;
+                            message.className =
+                                "message " +
+                                (data.status === "success"
+                                    ? "success"
+                                    : "error");
+                            message.style.display = "block";
+
+                            // Enable submit button
+                            form.querySelector(
+                                'button[type="submit"]',
+                            ).disabled = false;
+                        })
+                        .catch((error) => {
+                            console.error("Error:", error);
+
+                            // Hide loader
+                            loader.style.display = "none";
+
+                            // Show error message
+                            message.textContent =
+                                "An error occurred. Please try again.";
+                            message.className = "message error";
+                            message.style.display = "block";
+
+                            // Enable submit button
+                            form.querySelector(
+                                'button[type="submit"]',
+                            ).disabled = false;
+                        });
+                });
+            });
+        </script>
+    </body>
+</html>