Découvrez comment j’ai créé mon App nocode YouTube Transcriber & Cutter avec l’IA

import os
import re
import json
import subprocess
from flask import Flask, render_template, request
from youtube_transcript_api import YouTubeTranscriptApi

app = Flask(__name__)

def extract_video_id(url):
    """Extract the 11-character YouTube video ID from the URL."""
    pattern = r"(?:v=|\/)([a-zA-Z0-9_-]{11})"
    match = re.search(pattern, url)
    if match:
        return match.group(1)
    return None

def download_video(yt_url, output_file):
    """Download the YouTube video using yt-dlp."""
    command = ["yt-dlp", "-f", "best", "-o", output_file, yt_url]
    subprocess.run(command, check=True)

def get_video_length(yt_url):
    """Retrieve video length (in seconds) from yt-dlp metadata."""
    command = ["yt-dlp", "--dump-json", yt_url]
    result = subprocess.run(command, capture_output=True, text=True, check=True)
    data = json.loads(result.stdout)
    return data.get("duration", 0)

def cut_video(input_file, start_time, end_time, output_file):
    """Cut the video segment using FFmpeg from start_time to end_time."""
    duration = end_time - start_time
    command = [
        "ffmpeg",
        "-y",  # Overwrite output file if exists
        "-ss", str(start_time),
        "-i", input_file,
        "-t", str(duration),
        "-c", "copy",
        output_file
    ]
    subprocess.run(command, check=True)

def merge_videos(video_files, merged_filename):
    """Merge video segments using FFmpeg's concat demuxer."""
    list_filename = "segments_list.txt"
    with open(list_filename, "w") as f:
        for vf in video_files:
            f.write(f"file '{os.path.abspath(vf)}'\n")
    merge_cmd = [
        "ffmpeg",
        "-y",  # Overwrite output file if exists
        "-f", "concat",
        "-safe", "0",
        "-i", list_filename,
        "-c", "copy",
        merged_filename
    ]
    subprocess.run(merge_cmd, check=True)
    os.remove(list_filename)

@app.route("/", methods=["GET", "POST"])
def index():
    message = ""
    transcript_text = ""
    cut_results = []      # Messages for each extracted segment
    output_files = []     # List of extracted segment filenames

    if request.method == "POST":
        yt_url = request.form.get("yt_url")
        cut_method = request.form.get("cut_method")  # "between" or "around"
        trans_lang = request.form.get("trans_lang", "en").strip()  # Selected language
        merge_option = request.form.get("merge_segments")  # "on" if checked
        delete_option = request.form.get("delete_segments")  # "on" if checked
        video_id = extract_video_id(yt_url)

        if not video_id:
            message = "Invalid URL. Please enter a valid YouTube video URL."
        else:
            try:
                # Retrieve transcript using the selected language
                transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=[trans_lang])
                transcript_text = "\n".join([f"[{seg['start']:.2f}] {seg['text']}" for seg in transcript])
                
                # Download the video and get its length
                video_filename = f"{video_id}.mp4"
                download_video(yt_url, video_filename)
                video_length = get_video_length(yt_url)
                
                if cut_method == "between":
                    # Option 1: Between Precise Keywords
                    keyword_pairs_input = request.form.get("keyword_pairs", "").strip()
                    if keyword_pairs_input:
                        pairs = []
                        for line in keyword_pairs_input.splitlines():
                            if "," in line:
                                start_kw, end_kw = line.split(",", 1)
                                pairs.append((start_kw.strip().lower(), end_kw.strip().lower()))
                    else:
                        start_kw = request.form.get("start_keyword", "").strip().lower()
                        end_kw = request.form.get("end_keyword", "").strip().lower()
                        if start_kw and end_kw:
                            pairs = [(start_kw, end_kw)]
                        else:
                            pairs = []
                    
                    if not pairs:
                        message = "Please provide at least one valid keyword pair."
                    else:
                        for idx, (start_keyword, end_keyword) in enumerate(pairs, start=1):
                            start_index = None
                            end_index = None
                            for i, seg in enumerate(transcript):
                                text_lower = seg['text'].lower()
                                if start_index is None and start_keyword in text_lower:
                                    start_index = i
                                if start_index is not None and end_keyword in text_lower:
                                    end_index = i
                                    break
                            if start_index is None:
                                cut_results.append(f"Pair {idx}: Start keyword '{start_keyword}' not found.")
                                continue
                            if end_index is None:
                                cut_results.append(f"Pair {idx}: End keyword '{end_keyword}' not found after start keyword.")
                                continue
                            
                            seg_start = transcript[start_index]['start']
                            seg_end = transcript[end_index]['start']
                            output_filename = f"{video_id}_between_pair_{idx}.mp4"
                            cut_video(video_filename, seg_start, seg_end, output_filename)
                            output_files.append(output_filename)
                            cut_results.append(f"Pair {idx}: Segment created: {output_filename} (from {seg_start:.2f}s to {seg_end:.2f}s)")
                        message = "Processing complete for 'Between Precise Keywords' method."
                        
                elif cut_method == "around":
                    # Option 2: Around KW with separate durations
                    around_keywords_input = request.form.get("around_keywords", "").strip()
                    d_before_str = request.form.get("duration_before", "").strip()
                    d_after_str = request.form.get("duration_after", "").strip()
                    process_all = request.form.get("process_all")  # "on" if checked
                    
                    if not around_keywords_input or not d_before_str or not d_after_str:
                        message = "Please provide at least one keyword, a 'duration before', and a 'duration after' (in seconds) for the 'Around KW' option."
                    else:
                        try:
                            d_before = float(d_before_str)
                            d_after = float(d_after_str)
                        except ValueError:
                            message = "Both durations must be numeric values (in seconds)."
                            return render_template("index.html", message=message, transcript=transcript_text, cut_results=cut_results)
                        
                        # Split keywords on commas (entered on one line)
                        keywords = [kw.strip().lower() for kw in around_keywords_input.split(",") if kw.strip()]
                        if not keywords:
                            message = "Please provide at least one valid keyword."
                        else:
                            for kw in keywords:
                                occurrences = []
                                for seg in transcript:
                                    if kw in seg['text'].lower():
                                        occurrences.append(seg['start'])
                                
                                if not occurrences:
                                    cut_results.append(f"Keyword '{kw}' not found in the transcript.")
                                    continue
                                
                                if process_all != "on":
                                    occurrences = occurrences[:1]
                                
                                for idx, kw_time in enumerate(occurrences, start=1):
                                    start_time = max(0, kw_time - d_before)
                                    end_time = min(video_length, kw_time + d_after)
                                    output_filename = f"{video_id}_around_{kw}_{idx}.mp4"
                                    cut_video(video_filename, start_time, end_time, output_filename)
                                    output_files.append(output_filename)
                                    cut_results.append(f"Around '{kw}' occurrence {idx}: Segment created: {output_filename} (from {start_time:.2f}s to {end_time:.2f}s)")
                            message = "Processing complete for 'Around KW' method."
                else:
                    message = "Please choose a cutting method."
                
                # If merge option is checked and there are output files, merge them.
                if merge_option == "on" and output_files:
                    merged_filename = f"{video_id}_merged.mp4"
                    merge_videos(output_files, merged_filename)
                    cut_results.append(f"Merged video created: {merged_filename}")
                    message += " All segments have been merged."
                    
                    # If delete option is also checked, remove all individual segments and downloaded video.
                    if delete_option == "on":
                        for file in output_files:
                            if os.path.exists(file):
                                os.remove(file)
                        if os.path.exists(video_filename):
                            os.remove(video_filename)
                        cut_results.append("All individual segment files and the downloaded video have been deleted.")
            except Exception as e:
                message = f"Error during processing: {e}"
    return render_template("index.html", message=message, transcript=transcript_text, cut_results=cut_results)

if __name__ == "__main__":
    app.run(debug=True)