From 130a3292e40da30186d4e21ca93323fcb70ba5b7 Mon Sep 17 00:00:00 2001 From: rafa Date: Wed, 15 Jul 2026 03:20:48 +0000 Subject: [PATCH 1/2] feat: sync_carta_from_prod.py para copiar el cluster de una carta prod->local (#174) --- scripts/fea_translate_helper.php | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/scripts/fea_translate_helper.php b/scripts/fea_translate_helper.php index 74c6b97..dd35ec3 100644 --- a/scripts/fea_translate_helper.php +++ b/scripts/fea_translate_helper.php @@ -19,7 +19,7 @@ // Bootstrap portable. Si WP no está cargado (modo standalone), cargar wp-load. // Local (docker): /var/www/html/wp-load.php (por defecto). -// Prod: export FEA_WP_LOAD=/web/wp-nuevo/wp-load.php +// Prod: export FEA_WP_LOAD=/web/wp-load.php // (Si se ejecuta vía `wp eval-file`, ABSPATH ya está definido y no se recarga.) if (!defined('ABSPATH')) { $_SERVER['REQUEST_URI'] = $_SERVER['REQUEST_URI'] ?? '/'; @@ -262,6 +262,18 @@ switch ($cmd) { break; } + case 'carta_sections': { + // Descubre el cluster de una carta parseando sus propios enlaces internos + // (misma lógica que pinta la portada, fea-carta-portada.php). No depende + // de _carta_id -> sirve aunque ese meta todavía no se haya puesto. + $id = (int) ($argv[2] ?? 0); + if (!$id || !function_exists('fea_parse_carta_sections')) { + fwrite(STDERR, "fea_parse_carta_sections no disponible o id inválido\n"); exit(9); + } + out_json(fea_parse_carta_sections($id)); + break; + } + case 'save_translations': { $payload = json_decode(file_get_contents('php://stdin'), true); if (!is_array($payload) || empty($payload['translations']) || !is_array($payload['translations'])) { -- 2.52.0 From 2d03f5510c02534d7a0d259f7d22072c35092dfc Mon Sep 17 00:00:00 2001 From: rafa Date: Wed, 15 Jul 2026 03:20:49 +0000 Subject: [PATCH 2/2] feat: sync_carta_from_prod.py para copiar el cluster de una carta prod->local (#174) --- scripts/sync_carta_from_prod.py | 247 ++++++++++++++++++++++++++++++++ 1 file changed, 247 insertions(+) create mode 100644 scripts/sync_carta_from_prod.py diff --git a/scripts/sync_carta_from_prod.py b/scripts/sync_carta_from_prod.py new file mode 100644 index 0000000..6b814e7 --- /dev/null +++ b/scripts/sync_carta_from_prod.py @@ -0,0 +1,247 @@ +#!/usr/bin/env python3 +""" +sync_carta_from_prod.py — Copia una carta semanal (y su cluster de artículos) +de PROD a LOCAL preservando IDs, para poder traducir/locutar sobre un entorno +local alineado con prod. + +Por qué existe: desde que Inma/Mixbot componen y publican la carta ES +directamente en WordPress prod (issue #165, #174), el WP local de Rafa deja +de recibir ese contenido — solo lo tenía porque antes todo pasaba por el +delta Joomla->local->prod. Sin este script, local queda desalineado (visto +con la carta 735 / ID 54495: ese ID en local correspondía a OTRO post) y +traducir/locutar ahí es peligroso (contenido cruzado). Ver +gitea.feadulta.com/rafa/feadulta#174. + +Descubre el cluster parseando los enlaces internos de la propia carta +(fea_parse_carta_sections, la misma función que pinta la portada) en vez de +depender de _carta_id, que puede no estar puesto todavía. + +Es el espejo de sync_translations_to_prod.py (modo IDs preservados): reutiliza +el mismo fea_translate_helper.php sin tocar su lógica, solo invertido +(lee de prod por SSH, escribe en local por docker). + +Uso: + python3 sync_carta_from_prod.py --carta 54495 --dry-run + python3 sync_carta_from_prod.py --carta 54495 + +Tras esto, el resto del ciclo ya existente no cambia: + translate_post.py --carta 54495 --langs en,fr,it,pt --status draft + publish_carta.php + rotate_cartas.php CARTA=54495 APPLY=1 (en PROD, por idioma ya publicado) + tts_produce.py + sync_audio_to_prod.py +""" + +from __future__ import annotations + +import argparse +import json +import os +import subprocess +import time +from pathlib import Path + +WP_CONTAINER = os.environ.get("FEA_WP_CONTAINER", "wordpress-web") + +PROD_HOST = os.environ.get("FEA_PROD_SSH_HOST", "") +PROD_PASS = os.environ.get("FEA_PROD_SSH_PASS", "") +PROD_WPLOAD = os.environ.get("FEA_PROD_WPLOAD", "/web/wp-load.php") +PROD_HELPER = "/tmp/fea_translate_helper.php" + +HELPER_SRC = Path(__file__).resolve().parent / "fea_translate_helper.php" +LOCAL_HELPER_DST = "/tmp/fea_translate_helper.php" + +# Por defecto NO se fuerza status: cada post se clona con el status que tiene +# en prod (publish/draft). Ver fea_translate_helper.php:clone (status vacío -> +# usa payload['status']). +STATUS = os.environ.get("FEA_SYNC_DOWN_STATUS", "") +LOG_FILE = Path(os.environ.get("FEA_SYNC_DOWN_LOG", "/tmp/feadulta-sync-down.log")) + + +def log(msg: str) -> None: + line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}" + print(line, flush=True) + try: + LOG_FILE.open("a", encoding="utf-8").write(line + "\n") + except OSError: + pass + + +def sh(cmd: list[str], *, stdin: str | None = None, timeout: int = 120) -> str: + r = subprocess.run(cmd, input=stdin, capture_output=True, text=True, timeout=timeout) + if r.returncode != 0: + raise RuntimeError(f"cmd falló ({r.returncode}): {' '.join(cmd[:3])}…\n{r.stderr.strip()[:400]}") + return r.stdout + + +# ── Prod (origen, solo lectura) ───────────────────────────────────────────── +_prod_ready = False + + +def _ssh(remote_cmd: str, *, stdin: str | None = None, timeout: int = 120) -> str: + cmd = ["sshpass", "-p", PROD_PASS, "ssh", "-o", "StrictHostKeyChecking=accept-new", + "-o", "ConnectTimeout=20", PROD_HOST, remote_cmd] + return sh(cmd, stdin=stdin, timeout=timeout) + + +def prod_helper(subcmd: str, *args: str, stdin: str | None = None) -> str: + global _prod_ready + if not _prod_ready: + _ssh(f"cat > {PROD_HELPER}", stdin=HELPER_SRC.read_text(encoding="utf-8")) + _prod_ready = True + inner = f"FEA_WP_LOAD={PROD_WPLOAD} php {PROD_HELPER} {subcmd} " + " ".join(args) + return _ssh(inner, stdin=stdin, timeout=180) + + +def prod_read_full(post_id: int) -> dict: + return json.loads(prod_helper("read_full", str(post_id))) + + +def prod_carta_sections(carta_id: int) -> dict: + raw = prod_helper("carta_sections", str(carta_id)).strip() + return json.loads(raw) if raw else {} + + +def seed_ids_from_carta(carta_id: int) -> list[int]: + sections = prod_carta_sections(carta_id) + ids = {carta_id} + for arr in sections.values(): + for pid in arr: + ids.add(int(pid)) + return sorted(ids) + + +def collect_related_posts(seed_ids: list[int]) -> tuple[dict[int, dict], list[dict[str, int]]]: + posts: dict[int, dict] = {} + groups: dict[tuple[tuple[str, int], ...], dict[str, int]] = {} + + for seed in seed_ids: + info = prod_read_full(seed) + posts[seed] = info + raw_group = info.get("translations") or {} + group = {lang: int(pid) for lang, pid in raw_group.items() if str(pid).isdigit()} + if not group: + lang = info.get("lang") or "es" + group = {lang: seed} + sig = tuple(sorted(group.items())) + groups[sig] = group + + all_ids = sorted({pid for group in groups.values() for pid in group.values()}) + for pid in all_ids: + if pid not in posts: + posts[pid] = prod_read_full(pid) + + return posts, list(groups.values()) + + +# ── Local (destino) ────────────────────────────────────────────────────────── +_local_ready = False + + +def local_helper(subcmd: str, *args: str, stdin: str | None = None) -> str: + global _local_ready + if not _local_ready: + sh(["docker", "cp", str(HELPER_SRC), f"{WP_CONTAINER}:{LOCAL_HELPER_DST}"]) + _local_ready = True + return sh(["docker", "exec", "-i", WP_CONTAINER, "php", LOCAL_HELPER_DST, subcmd, *args], + stdin=stdin, timeout=180) + + +def local_read_safe(post_id: int) -> dict | None: + try: + return json.loads(local_helper("read", str(post_id))) + except RuntimeError: + return None + + +def local_clone(post: dict) -> int: + payload = { + "title": post["title"], + "content": post.get("content", ""), + "excerpt": post.get("excerpt", ""), + "slug": post.get("slug", ""), + "type": post.get("type", "post"), + "author": post.get("author", 1), + "date": post.get("date"), + "date_gmt": post.get("date_gmt"), + "status": post.get("status"), + "cats": post.get("cats", []), + "cat_slugs": post.get("cat_slugs", []), + "meta": post.get("meta", {}), + } + out = local_helper("clone", str(post["id"]), post.get("lang") or "es", STATUS, + stdin=json.dumps(payload)).strip() + return int(out) + + +def local_save_group(group: dict[str, int]) -> dict[str, int]: + out = local_helper("save_translations", stdin=json.dumps({"translations": group})).strip() + return json.loads(out) + + +# ── Main ───────────────────────────────────────────────────────────────────── +def sync_carta(carta_id: int, *, dry_run: bool) -> int: + seed_ids = seed_ids_from_carta(carta_id) + log(f"Cluster descubierto desde fea_parse_carta_sections(prod#{carta_id}): " + f"{len(seed_ids)} post(s) -> {seed_ids}") + if not seed_ids or seed_ids == [carta_id]: + log(" ⚠️ El parser no resolvió ningún artículo enlazado (¿carta sin publicar aún, " + "o secciones sin encabezados reconocibles?). Revisa antes de continuar.") + + posts, groups = collect_related_posts(seed_ids) + + conflicts = [] + for pid, p in posts.items(): + existing = local_read_safe(pid) + if existing and existing.get("title") != p.get("title"): + conflicts.append((pid, existing.get("title", ""), p.get("title", ""))) + + if conflicts: + log(f" ⚠️ {len(conflicts)} CONFLICTO(S): el ID ya existe en local con OTRO contenido " + f"y va a ser SOBRESCRITO:") + for pid, old_title, new_title in conflicts: + log(f" #{pid}: local actual «{old_title[:50]}» -> prod «{new_title[:50]}»") + + if dry_run: + for pid, p in posts.items(): + log(f" PULL prod#{pid} [{p.get('lang','?')}] status={p.get('status')} " + f"slug={p.get('slug','')} «{p.get('title','')[:50]}»") + for group in groups: + log(f" GROUP {group}") + log("DRY-RUN: nada escrito en local.") + return 0 + + for pid, p in posts.items(): + new_id = local_clone(p) + if new_id != pid: + log(f" ⚠️ prod#{pid} se clonó como local#{new_id} — ID NO preservado, revisar a mano.") + else: + log(f" clone prod#{pid} -> local#{new_id} [{p.get('lang','?')}] «{p['title'][:45]}»") + + for group in groups: + if len(group) < 2: + continue + saved = local_save_group(group) + log(f" group enlazado en local {saved}") + + log(f"FIN sync prod->local. carta={carta_id} posts={len(posts)} conflictos_previos={len(conflicts)}") + return 0 + + +def main() -> int: + ap = argparse.ArgumentParser( + description="Copia una carta (y su cluster de artículos) de PROD a LOCAL preservando IDs.") + ap.add_argument("--carta", type=int, required=True, help="ID del post ES de la carta en PROD.") + ap.add_argument("--dry-run", action="store_true", help="Solo muestra el plan; no escribe en local.") + args = ap.parse_args() + + if not PROD_HOST or not PROD_PASS: + raise SystemExit( + "Faltan FEA_PROD_SSH_HOST / FEA_PROD_SSH_PASS en el entorno.\n" + "Antes de ejecutar: source ~/.hermes/profiles/feadulta/.env" + ) + + return sync_carta(args.carta, dry_run=args.dry_run) + + +if __name__ == "__main__": + raise SystemExit(main()) -- 2.52.0