El proyecto douyin_downloader es una herramienta de código abierto construida sobre una arquitectura dual que combina Python y Electron. Su funcionalidad principal consiste en obtener directamente el flujo de video original desde los servidores de Douyin, logrando descargas sin marcas de agua y con calidad original mediante el análisis de enlaces compartidos.

Mecanismo de Análisis Principal

El núcleo técnico radica en evitar el proceso de marcado de agua de la plataforma, accediendo directamente a los archivos de video almacenados en el servidor. El procedimiento se ejecuta mediante las siguientes etapas:

1. Resolución de Redirección URL: Los enlaces compartidos de Douyin se redirigen hacia la página real del video
2. Extracción de Contenido HTML: Se utiliza la biblioteca Requests para obtener el código fuente de la página
3. Localización del Recurso de Video: Se analiza la estructura DOM con BeautifulSoup para encontrar la etiqueta <video class="video-player">
4. Estrategia de Evasión de Marca de Agua: Reemplazar la ruta /playwm/ por /play/ para acceder al flujo sin procesar

Diseño de Arquitectura Dual

Gestión de Configuración

El sistema emplea archivos INI para gestionar diferentes configuraciones de User-Agent:

[desktop-headers]
user-agent = Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...

[mobile-headers]
user-agent = Mozilla/5.0 (Linux; Android 10; SM-G973F) AppleWebKit/537.36...

Guía de Implementación

Versión de Línea de Comandos

El módulo CLI se encuentra en el directorio python3/ y requiere las siguientes dependencias:

pip install requests beautifulsoup4 lxml

Versión con Interfaz Gráfica

La aplicación de escritorio se basa en Electron y se despliega mediante:

cd electron
npm install
npm start

Detalles de Implementación

Función de Análisis de Video

El método principal analyze_video_source() implementa la lógica de extracción:

import requests
from bs4 import BeautifulSoup
import os

def analyze_video_source(target_url, request_headers):
    # Obtener contenido de la página
    http_response = requests.get(
        target_url, 
        headers=request_headers, 
        verify=False,
        allow_redirects=True
    )
    http_response.encoding = 'utf-8'
    page_content = http_response.text
    
    # Procesar estructura DOM
    soup_parser = BeautifulSoup(page_content, 'lxml')
    video_element = soup_parser.find("video", class_='video-player')
    
    # Extraer y transformar URL del video
    watermarked_url = video_element.get("src")
    clean_url = watermarked_url.replace("/playwm/", "/play/")
    
    # Identificador único del video
    content_id = extract_video_id(page_content)
    
    return {
        "original_url": watermarked_url,
        "clean_url": clean_url,
        "video_id": content_id
    }

def extract_video_id(html_content):
    marker = 'itemId: "'
    start_idx = html_content.find(marker) + len(marker)
    end_idx = html_content.find('"', start_idx)
    return html_content[start_idx:end_idx]

Módulo de Descarga

def save_video_file(video_metadata, request_headers, output_dir="downloads"):
    # Crear directorio de destino
    os.makedirs(output_dir, mode=0o755, exist_ok=True)
    
    # Obtener flujo de video
    video_stream = requests.get(
        video_metadata['clean_url'], 
        headers=request_headers, 
        stream=True,
        verify=False
    )
    
    # Construir ruta de archivo
    output_filename = f"{video_metadata['video_id']}.mp4"
    full_path = os.path.join(output_dir, output_filename)
    
    # Escribir archivo con chunks
    with open(full_path, "wb") as output_file:
        for chunk in video_stream.iter_content(chunk_size=8192):
            output_file.write(chunk)
    
    return os.path.abspath(full_path)

Comunicación entre Procesos en Electron

La arquitectura de la aplicación de escritorio implementa el patrón de procesos separados:

• Proceso Principle (main.js): Gestiona ventanas y eventos del sistema
• Proceso de Renderizado (renderer.js): Maneja la interfaz de usuario
• Script de Precarga (preload.js): Expone APIs de Node.js de forma segura mediante contextBridge

Parámetros de Configuración de Red

Extensiones y Personalización

Procesamiento por Lotes

def process_batch_urls(url_collection, headers_config):
    results = []
    
    for idx, current_url in enumerate(url_collection):
        try:
            metadata = analyze_video_source(current_url, headers_config)
            saved_path = save_video_file(metadata, headers_config)
            results.append({
                "index": idx,
                "status": "success",
                "path": saved_path
            })
        except Exception as error:
            results.append({
                "index": idx,
                "status": "failed",
                "error": str(error)
            })
    
    return results

Integración con Proxy

def create_request_session(proxy_config=None):
    session = requests.Session()
    
    if proxy_config:
        session.proxies = {
            'http': proxy_config.get('http_proxy'),
            'https': proxy_config.get('https_proxy')
        }
    
    return session

# Uso
proxy_settings = {
    'http_proxy': 'http://127.0.0.1:8080',
    'https_proxy': 'http://127.0.0.1:8080'
}
request_session = create_request_session(proxy_settings)

Manejo de Errores Mejorado

import logging
from functools import wraps

def retry_on_failure(max_attempts=3, delay_seconds=2):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    logging.warning(f"Intento {attempt + 1} fallido: {e}")
                    if attempt < max_attempts - 1:
                        import time
                        time.sleep(delay_seconds)
            raise last_exception
        return wrapper
    return decorator

@retry_on_failure(max_attempts=3)
def download_with_retry(url, headers):
    return requests.get(url, headers=headers, timeout=30)

Configuración de Almacenamiento

Hoja de Ruta Técnica

Desarrollos planificados para futuras versiones:

• API REST para integración con servicios externos
• Extensión de navegador para descarga directa desde la web
• Soporte para múltiples resoluciones de video
• Integración con servicios de almacenamiento en la nube
• Sistema de progreso de descarga en tiempo real