Desglose técnico de
MoneyPrinterTurbo

Si no se proporciona un guion manual, el sistema llama al LLM configurado para redactar un texto adaptado al formato de vídeo corto. Soporta más de 20 providers con una interfaz unificada: OpenAI, Gemini, DeepSeek, Groq, Claude (vía LiteLLM), Ollama (local), y muchos más.

def generate_script(params: VideoParams) -> str:
    prompt = build_script_prompt(
        subject=params.video_subject,
        paragraphs=params.paragraph_number,
        language=params.video_language
    )
    for attempt in range(5):
        try:
            resp = llm_request(prompt)
            return clean_script(resp)
        except Exception as e:
            logger.warning(f"Attempt {attempt+1} failed: {e}")
    raise RuntimeError("Script generation failed")

El prompt incluye el tema, número de párrafos, idioma y un system prompt que instruye al modelo a escribir para formato de vídeo corto (oraciones directas, transiciones naturales). La respuesta se limpia de caracteres markdown antes de devolverla.

Una vez listo el guion, se pide al LLM que genere entre 5 y 8 keywords en inglés para buscar stock footage. Con la opción match_materials_to_script, los términos se ordenan cronológicamente para que el metraje coincida con la narrativa.

def generate_terms(script: str, style: str, language: str) -> list:
    prompt = f"Generate 5-8 English search terms for stock video about:\n{script}"
    for attempt in range(5):
        raw = llm_request(prompt)
        try:
            terms = json.loads(raw)
            if isinstance(terms, list) and len(terms) >= 3:
                return terms
        except json.JSONDecodeError:
            match = re.findall(r'"([^"]+)"', raw)
            if match: return match

El LLM devuelve un array JSON. Si el parseo falla, un regex extrae los strings entre comillas como fallback. Esto asegura robustez ante respuestas mal formateadas.

El texto del guion se convierte en audio mediante uno de 6 motores TTS. El sistema selecciona el provider según la configuración y maneja automáticamente la obtención de timestamps palabra por palabra para sincronizar subtítulos.

def tts(params: VideoParams) -> tuple[str, SubMaker]:
    provider = params.tts_provider
    if provider == "edge":
        return edge_tts_v1(params)
    elif provider == "azure":
        return azure_tts_v2(params)
    elif provider == "siliconflow":
        return siliconflow_tts(params)
    elif provider == "gemini":
        return gemini_tts(params)
    elif provider == "mimo":
        return mimo_tts(params)
    else:
        return no_voice(params)  # silencio + duración estimada

Todos los providers devuelven un objeto SubMaker que contiene los timestamps palabra por palabra, esenciales para la generación precisa de subtítulos. Edge TTS los obtiene via eventos WordBoundary; Azure via callbacks del SDK.

Dos providers disponibles: edge (usa los cues de Edge TTS, rápido, sin GPU) y whisper (ejecuta faster-whisper localmente, más preciso pero requiere descarga del modelo ~3GB).

def generate_subtitle(audio_path: str, sub_maker: SubMaker,
                       provider: str) -> str:
    if provider == "edge":
        return sub_maker.generate_srt()
    elif provider == "whisper":
        model = WhisperModel("large-v3", device="cuda",
                             compute_type="float16")
        segments, _ = model.transcribe(audio_path)
        return segments_to_srt(segments)

Ambos caminos convergen en una función de corrección post-procesado que alinea los textos del SRT con el guion original usando distancia Levenshtein, asegurando que los subtítulos coincidan exactamente con lo que el LLM generó.

Para cada término de búsqueda, el sistema consulta 3 APIs de stock video (Pexels, Pixabay, Coverr), descarga los clips de mayor resolución y los almacena en caché con un sistema de deduplicación por hash MD5.

def get_video_materials(params: VideoParams) -> list[MaterialInfo]:
    materials = []
    source = params.video_source  # "pexels" | "pixabay" | "coverr" | "local"
    for keyword in params.video_terms:
        api_clips = search_pexels(keyword) if source == "pexels" else ...
        for clip in api_clips:
            hash_key = hashlib.md5(clip.url.encode()).hexdigest()
            if hash_key in seen: continue
            seen.add(hash_key)
            if download_video(clip.url, dest):
                materials.append(MaterialInfo(...))
    return materials

Los clips descargados se validan con MoviePy (duración > 0, FPS > 0). Con match_materials_to_script, los clips se asignan a segmentos específicos del guion en orden cronológico.

La etapa más compleja. MoviePy compone todos los elementos: clips de vídeo, transiciones, subtítulos sincronizados, voz superpuesta y música de fondo. El resultado se codifica con FFmpeg usando el codec configurado.

Soporta dos relaciones de aspecto: 9:16 (1080×1920, vertical/portrait) y 16:9 (1920×1080, horizontal/landscape). Los clips con relación distinta se centran con barras negras (letterbox). El codec de video se configura vía video_codec (libx264, NVENC, AMF, QSV, VideoToolbox).