Cómo Migrar WordPress a Static Site con Python

wp2static/
├── wp2static.py          # CLI principal
├── config.example.yaml   # Plantilla de configuración
├── modules/
│   ├── config.py         # Carga y validación de config YAML
│   ├── session.py        # Sesión HTTP con reintentos
│   ├── auth.py           # Autenticación (App Passwords, cookies)
│   ├── crawler.py        # BFS crawl + descubrimiento por sitemap
│   ├── sanitizer.py      # Limpieza y normalización de slugs
│   ├── assets.py         # Descarga de imágenes y recursos
│   ├── transformer.py    # Transformación HTML, reescritura de enlaces
│   ├── structure.py      # Reorganización de directorios
│   ├── pagination.py     # Generación de páginas de índice y categoría
│   ├── redirects.py      # Generación de _redirects (Cloudflare)
│   ├── sitemap.py        # Generación de sitemap.xml
│   ├── search_index.py   # Generación de search-index.json
│   └── validator.py      # Validación post-exportación
└── requirements.txt

# config.yaml
source:
  url: "https://tu-wordpress.com"
  auth:
    method: "app_password"
    username: "admin"
    # La password se lee de la variable de entorno WP2STATIC_PASSWORD
    password_env: "WP2STATIC_PASSWORD"

output:
  directory: "./output"
  url: "https://tu-sitio-estatico.com"

crawl:
  max_depth: 50
  concurrent_requests: 5
  timeout: 30
  respect_robots: true
  additional_urls:
    - "/sitemap.xml"
    - "/feed/"

transform:
  remove_wp_elements: true
  rewrite_urls: true
  download_assets: true
  clean_html: true

categories:
  cloud-devops: "Cloud & DevOps"
  cybersecurity: "Cybersecurity"
  linux-systems: "Linux & Systems"
  networks-infrastructure: "Networks & Infrastructure"
  siem-monitoring: "SIEM & Monitoring"
  dfir-threat-intel: "DFIR & Threat Intel"
  development-other: "Development & Other"

# Ejemplo simplificado del crawler BFS
from collections import deque
from bs4 import BeautifulSoup
import requests

def crawl(start_url, session, max_depth=50):
    visited = set()
    queue = deque([(start_url, 0)])
    pages = {}

    while queue:
        url, depth = queue.popleft()
        if url in visited or depth > max_depth:
            continue
        visited.add(url)

        response = session.get(url)
        if response.status_code != 200:
            continue

        pages[url] = response.text
        soup = BeautifulSoup(response.text, 'html.parser')

        for link in soup.find_all('a', href=True):
            href = normalize_url(link['href'], start_url)
            if is_internal(href, start_url) and href not in visited:
                queue.append((href, depth + 1))

    return pages

# Elementos a eliminar del HTML
REMOVE_SELECTORS = [
    'link[rel="EditURI"]',
    'link[rel="wlwmanifest"]',
    'link[rel="pingback"]',
    'meta[name="generator"]',
    'script[src*="wp-includes"]',
    'script[src*="wp-content"]',
    'link[href*="wp-includes"]',
    'link[href*="wp-content/plugins"]',
    '#wpadminbar',
    '.wp-block-spacer',
    'noscript[id*="rocket"]',  # WP Rocket artifacts
    'style[id*="global-styles"]',
]

def clean_wp_elements(soup):
    for selector in REMOVE_SELECTORS:
        for element in soup.select(selector):
            element.decompose()

def rewrite_urls(soup, source_url, target_url):
    # Reescribir href en enlaces
    for a in soup.find_all('a', href=True):
        a['href'] = a['href'].replace(source_url, target_url)

    # Reescribir src en imágenes y scripts
    for tag in soup.find_all(['img', 'script', 'source'], src=True):
        tag['src'] = tag['src'].replace(source_url, target_url)

    # Reescribir href en links CSS
    for link in soup.find_all('link', href=True):
        link['href'] = link['href'].replace(source_url, target_url)

import unicodedata
import re

def sanitize_slug(slug):
    # Normalizar Unicode (NFD) y eliminar diacríticos
    slug = unicodedata.normalize('NFD', slug)
    slug = slug.encode('ascii', 'ignore').decode('ascii')

    # Convertir a minúsculas y reemplazar espacios
    slug = slug.lower().strip()
    slug = re.sub(r'[^a-z0-9\-]', '-', slug)
    slug = re.sub(r'-+', '-', slug)
    slug = slug.strip('-')

    return slug

# Estructura de assets resultante
# wp-content/uploads/2020/03/imagen.jpg
#   → assets/images/posts/2020/03/imagen.jpg

def download_assets(soup, output_dir, session):
    for img in soup.find_all('img', src=True):
        src = img['src']
        if 'wp-content/uploads' in src:
            # Calcular ruta local
            path_part = src.split('wp-content/uploads/')[-1]
            local_path = os.path.join(output_dir, 'assets/images/posts', path_part)

            # Descargar si no existe
            if not os.path.exists(local_path):
                os.makedirs(os.path.dirname(local_path), exist_ok=True)
                response = session.get(src)
                with open(local_path, 'wb') as f:
                    f.write(response.content)

            # Actualizar la referencia en el HTML
            img['src'] = f'/assets/images/posts/{path_part}'

output/
├── index.html                              # Página principal
├── sitemap.xml                             # Sitemap para buscadores
├── search-index.json                       # Índice de búsqueda
├── _redirects                              # Redirecciones Cloudflare
├── _headers                                # Cabeceras de seguridad
├── assets/
│   ├── css/
│   │   ├── main.css
│   │   └── posts.css
│   ├── js/
│   │   ├── main.js
│   │   └── search.js
│   └── images/
│       └── posts/
│           ├── 2015/01/imagen1.jpg
│           ├── 2020/03/imagen2.png
│           └── unsplash/defaults/          # Imágenes por defecto
├── posts/
│   ├── 2015/
│   │   └── 01/
│   │       └── mi-primer-post/
│   │           └── index.html
│   └── 2025/
│       └── 04/
│           └── migrar-wordpress-a-sitio-estatico/
│               └── index.html
├── category/
│   ├── cloud-devops/
│   │   ├── index.html                      # Página 1
│   │   └── page/
│   │       ├── 2/index.html
│   │       └── 3/index.html
│   └── cybersecurity/
│       ├── index.html
│       └── page/...
└── page/
    ├── 2/index.html                        # Paginación global
    ├── 3/index.html
    └── ...

POSTS_PER_PAGE = 12

def generate_pagination(posts, output_dir, template):
    total_pages = math.ceil(len(posts) / POSTS_PER_PAGE)

    for page_num in range(1, total_pages + 1):
        start = (page_num - 1) * POSTS_PER_PAGE
        end = start + POSTS_PER_PAGE
        page_posts = posts[start:end]

        # Página 1 va en index.html, el resto en page/N/index.html
        if page_num == 1:
            path = os.path.join(output_dir, 'index.html')
        else:
            path = os.path.join(output_dir, f'page/{page_num}/index.html')

        html = render_page(template, page_posts, page_num, total_pages)
        os.makedirs(os.path.dirname(path), exist_ok=True)
        with open(path, 'w') as f:
            f.write(html)

# _redirects (formato Cloudflare Pages)
/2020/03/mi-post-antiguo/  /posts/2020/03/mi-post-antiguo/  301
/category/seguridad/        /category/cybersecurity/          301
/?p=123                     /posts/2020/03/mi-post-antiguo/  301
/feed/                      /sitemap.xml                     301

# _headers
/*
  X-Frame-Options: DENY
  X-Content-Type-Options: nosniff
  Referrer-Policy: strict-origin-when-cross-origin
  Permissions-Policy: camera=(), microphone=(), geolocation=()
  Content-Security-Policy: default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com; img-src 'self' data: https:; frame-src https://giscus.app https://www.youtube.com https://www.youtube-nocookie.com
  Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

# Validaciones que ejecuta el módulo validator
def validate_export(output_dir, source_url):
    errors = []

    # 1. Verificar que cada post tiene index.html
    for post_dir in glob.glob(f'{output_dir}/posts/*/*/*/'):
        if not os.path.exists(os.path.join(post_dir, 'index.html')):
            errors.append(f'Missing index.html: {post_dir}')

    # 2. Verificar que no quedan referencias al dominio WordPress
    for html_file in glob.glob(f'{output_dir}/**/*.html', recursive=True):
        with open(html_file) as f:
            content = f.read()
            if source_url in content:
                errors.append(f'WP URL found in: {html_file}')

    # 3. Verificar que las imágenes referenciadas existen
    for html_file in glob.glob(f'{output_dir}/**/*.html', recursive=True):
        soup = BeautifulSoup(open(html_file).read(), 'html.parser')
        for img in soup.find_all('img', src=True):
            if img['src'].startswith('/'):
                local_path = os.path.join(output_dir, img['src'].lstrip('/'))
                if not os.path.exists(local_path):
                    errors.append(f'Missing image: {img["src"]} in {html_file}')

    # 4. Verificar sitemap.xml
    if not os.path.exists(f'{output_dir}/sitemap.xml'):
        errors.append('Missing sitemap.xml')

    return errors

# Inicializar repositorio Git
cd output/
git init
git add -A
git commit -m "feat(site): initial static export from WordPress"

# Añadir remote y push
git remote add origin git@github.com:tu-org/tu-sitio.github.io.git
git push -u origin main

# Exportación completa
export WP2STATIC_PASSWORD="tu_app_password"
python3 wp2static.py --config config.yaml

# Solo validación (sin exportar)
python3 wp2static.py --config config.yaml --validate-only

# Modo dry-run (simula sin escribir)
python3 wp2static.py --config config.yaml --dry-run

# Reanudar exportación interrumpida
python3 wp2static.py --config config.yaml --resume