probando si funciona el json -> pdf

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.11-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+WORKDIR /app
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wkhtmltopdf \
+        fonts-dejavu-core \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app/ app/
+
+ENV PYTHONUNBUFFERED=1
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn app.main:app --host 0.0.0.0 --port ${PORT:-7860}"]

app/__init__.py/config.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+import pdfkit
+
+# Carpeta de este módulo (app/)
+BASE_DIR = Path(__file__).parent
+
+# Cache de configuración de pdfkit
+# False  => aún no inicializado
+# None   => se intentó inicializar pero no se encontró wkhtmltopdf
+# config => configuración válida
+_PDFKIT_CONFIG: Optional[pdfkit.configuration] | bool = False
+
+
+def _detect_wkhtmltopdf() -> Optional[str]:
+    """
+    Para entorno Docker (Linux):
+
+      1) Si hay WKHTMLTOPDF_PATH y apunta a un archivo, usarlo.
+      2) Si no, devolver None y dejar que pdfkit use lo que haya en PATH.
+
+    No nos preocupamos por .exe ni por Windows aquí.
+    """
+    env_path = os.getenv("WKHTMLTOPDF_PATH")
+    if env_path and Path(env_path).is_file():
+        return env_path
+
+    # None = que pdfkit use wkhtmltopdf del PATH (/usr/bin/wkhtmltopdf)
+    return None
+
+
+def get_pdfkit_config() -> Optional[pdfkit.configuration]:
+    """
+    Devuelve una instancia de pdfkit.configuration o None si
+    no se pudo inicializar wkhtmltopdf.
+    """
+    global _PDFKIT_CONFIG
+
+    if _PDFKIT_CONFIG is not False:
+        return _PDFKIT_CONFIG  # type: ignore[return-value]
+
+    wkhtml_path = _detect_wkhtmltopdf()
+
+    try:
+        if wkhtml_path:
+            _PDFKIT_CONFIG = pdfkit.configuration(wkhtmltopdf=wkhtml_path)
+            logging.info("wkhtmltopdf detectado en WKHTMLTOPDF_PATH: %s", wkhtml_path)
+        else:
+            # Usar binario en PATH (caso normal en Docker: /usr/bin/wkhtmltopdf)
+            _PDFKIT_CONFIG = pdfkit.configuration()
+            logging.info("wkhtmltopdf detectado en PATH.")
+    except OSError as exc:
+        logging.error("No se pudo inicializar pdfkit: %s", exc)
+        _PDFKIT_CONFIG = None
+
+    return _PDFKIT_CONFIG  # type: ignore[return-value]

app/__init__.py/main.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import io
+from typing import Any, Dict, Literal, Optional
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse, StreamingResponse
+from pydantic import BaseModel, Field
+
+from .renderer import render_html, render_pdf_bytes
+
+app = FastAPI(
+    title="Doc Compiler Service",
+    version="1.0.0",
+    description=(
+        "Servicio de compilación que recibe JSON de documentación, "
+        "renderiza plantillas Jinja2 y devuelve HTML o PDF."
+    ),
+)
+
+
+class CompileRequest(BaseModel):
+    doc: Dict[str, Any] = Field(
+        ...,
+        description="JSON de documentación generado por la IA (incluyendo metadata.script_type).",
+    )
+    job_id: Optional[str] = Field(
+        None,
+        description="Identificador opcional para el archivo (por ejemplo, nombre del script o job).",
+    )
+    output: Literal["html", "pdf"] = Field(
+        "pdf",
+        description="Tipo de salida deseada. En estos endpoints se usa como referencia.",
+    )
+
+
+@app.get("/health")
+def health_check():
+    """
+    Endpoint simple de healthcheck para monitoreo.
+    """
+    return {"status": "ok"}
+
+
+@app.post("/compile/html")
+def compile_html(req: CompileRequest):
+    """
+    Recibe JSON y devuelve el HTML renderizado (útil para depuración o previsualización).
+    """
+    if not req.doc:
+        raise HTTPException(status_code=400, detail="Campo 'doc' es obligatorio")
+
+    try:
+        html = render_html(req.doc)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Error al renderizar HTML: {exc}")
+
+    return HTMLResponse(content=html)
+
+
+@app.post("/compile/pdf")
+def compile_pdf(req: CompileRequest):
+    """
+    Recibe JSON y devuelve el PDF compilado usando wkhtmltopdf.
+    """
+    if not req.doc:
+        raise HTTPException(status_code=400, detail="Campo 'doc' es obligatorio")
+
+    job_id = req.job_id or "document"
+
+    try:
+        pdf_bytes = render_pdf_bytes(req.doc)
+    except RuntimeError as exc:
+        raise HTTPException(status_code=500, detail=str(exc))
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Error al generar PDF: {exc}")
+
+    filename = f"{job_id}.pdf"
+
+    return StreamingResponse(
+        io.BytesIO(pdf_bytes),
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )

app/__init__.py/renderer.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict
+
+import pdfkit
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from .config import BASE_DIR, get_pdfkit_config
+
+# Carpeta de plantillas Jinja2
+TEMPLATES_DIR = BASE_DIR / "templates"
+
+# Mapeo script_type -> plantilla
+TEMPLATE_MAP: Dict[str, str] = {
+    "RESTlet": "RESTlet.html.j2",
+    "ClientScript": "ClientScript.html.j2",
+    "Map/Reduce": "MapReduce.html.j2",
+    "MapReduce": "MapReduce.html.j2",
+    "Scheduled": "ScheduledScript.html.j2",
+    "ScheduledScript": "ScheduledScript.html.j2",
+    "Suitelet": "Suitelet.html.j2",
+    "UserEvent": "UserEventScript.html.j2",
+    "UserEventScript": "UserEventScript.html.j2",
+    "UserModule.js": "InternalModule.html.j2",
+    "InternalModule": "InternalModule.html.j2",
+}
+
+# Entorno Jinja
+env = Environment(
+    loader=FileSystemLoader(str(TEMPLATES_DIR)),
+    autoescape=select_autoescape(["html", "xml"]),
+    trim_blocks=True,
+    lstrip_blocks=True,
+)
+
+
+def _resolve_template(doc: Dict[str, Any]) -> str:
+    """
+    A partir del JSON determina qué plantilla Jinja usar
+    leyendo metadata.script_type o metadata.type.
+    """
+    metadata = doc.get("metadata") or {}
+    script_type = (
+        metadata.get("script_type") or metadata.get("type") or "InternalModule"
+    )
+    return TEMPLATE_MAP.get(script_type, "InternalModule.html.j2")
+
+
+def render_html(doc: Dict[str, Any]) -> str:
+    """
+    Renderiza el HTML final a partir del JSON y la plantilla Jinja2 apropiada.
+    """
+    template_name = _resolve_template(doc)
+    template = env.get_template(template_name)
+
+    html = template.render(
+        doc=doc,
+        generated_at=datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC"),
+    )
+    return html
+
+
+def _wkhtml_options() -> Dict[str, str]:
+    """
+    Opciones por defecto para wkhtmltopdf.
+    """
+    return {
+        "page-size": "A4",
+        "encoding": "UTF-8",
+        "margin-top": "20mm",
+        "margin-right": "20mm",
+        "margin-bottom": "20mm",
+        "margin-left": "20mm",
+    }
+
+
+def render_pdf_bytes(doc: Dict[str, Any]) -> bytes:
+    """
+    Toma el JSON, renderiza el HTML y lo compila a PDF (bytes en memoria).
+    Lanza RuntimeError si wkhtmltopdf no está disponible.
+    """
+    html = render_html(doc)
+    config = get_pdfkit_config()
+
+    if config is None:
+        raise RuntimeError("wkhtmltopdf no disponible en el servicio doc-compiler.")
+
+    pdf_bytes = pdfkit.from_string(
+        html,
+        False,  # False => devuelve bytes en vez de escribir archivo
+        options=_wkhtml_options(),
+        configuration=config,
+    )
+    return pdf_bytes

requirements.txt

@@ -0,0 +1,5 @@
+fastapi
+uvicorn[standard]
+jinja2
+pdfkit
+pydantic