") + ""),
+ "colspan": 1,
+ "rowspan": span_count,
+ }
+ rows.append([left, right])
+ elif idx < merged_end:
+ # Subsequent merged rows — no right cell (covered by rowspan)
+ rows.append([left])
+ else:
+ # Remaining rows — empty right cell
+ rows.append([
+ left,
+ {"text": "", "colspan": 1, "rowspan": 1},
+ ])
+
+ return rows
+
+
+def _extract_rate_italic(text: str) -> str:
+ """Extract the italic portion: 'Interest rate of 12% – 15% Market Rate PA'."""
+ # Text is like: "Interest rate of 12% – 15% Market Rate: UP TO USD 10,000"
+ m = re.match(r"(Interest rate.*?(?:Market Rate|PA))", text, re.IGNORECASE)
+ if m:
+ return m.group(1).rstrip(": ")
+ # Fallback: everything before the colon
+ if ":" in text:
+ return text.split(":")[0].strip()
+ return text
+
+
+def _extract_rate_amount(text: str) -> str:
+ """Extract the amount portion: 'UP TO USD 10,000'."""
+ m = re.search(r"(UP TO.*)", text, re.IGNORECASE)
+ if m:
+ return m.group(1).strip()
+ if ":" in text:
+ return text.split(":", 1)[1].strip()
+ return ""
+
+
+# ───────────────────────────────────────────────────────────────
+# Tier 2 (cosigner) section post-processor
+# ───────────────────────────────────────────────────────────────
+
+def _postprocess_tier2(blocks: list[RenderBlock]) -> list[RenderBlock]:
+ """Style the Tier 2 section to match the reference layout.
+
+ - Second consecutive bullet_list (sub-bullets under Sources of Funds)
+ gets checkmark styling instead of arrows.
+ """
+ result: list[RenderBlock] = []
+ prev_was_bullet = False
+ for blk in blocks:
+ if blk.block_type == "bullet_list":
+ if prev_was_bullet:
+ # This is the sub-bullet list → use checkmark class
+ result.append(RenderBlock(
+ block_type="bullet_list",
+ css_class="hb-bullet-list hb-sub-bullets",
+ data=blk.data,
+ ))
+ else:
+ result.append(blk)
+ prev_was_bullet = True
+ else:
+ prev_was_bullet = False
+ result.append(blk)
+ return result
+
+
+def _normalize_doc_v1(blocks: list, *, skip_title: str = "") -> list[RenderBlock]:
+ """Normalise doc_v1 blocks into typed RenderBlocks.
+
+ Args:
+ skip_title: When set, any leading heading/subheading block whose text
+ matches this title (case-insensitive) is dropped to avoid
+ duplicating the section heading already emitted by the caller.
+ """
+ from markupsafe import Markup
+ _skip_norm = skip_title.strip().lower() if skip_title else ""
+ result: list[RenderBlock] = []
+ for b in blocks:
+ if not isinstance(b, dict):
+ continue
+ btype = str(b.get("type", ""))
+
+ # Skip heading/subheading blocks that duplicate the section title
+ if _skip_norm and btype in ("heading", "subheading"):
+ block_text = str(b.get("text", "")).strip().lower()
+ if block_text == _skip_norm:
+ continue
+
+ if btype == "paragraph":
+ t = _normalize_text_content(str(b.get("text", "")))
+ if t.strip():
+ result.append(RenderBlock(
+ block_type="paragraph",
+ css_class="hb-paragraph",
+ data={
+ "text": t,
+ "html": Markup(emphasize_keywords(t)),
+ },
+ ))
+
+ elif btype == "subheading":
+ t = _normalize_text_content(str(b.get("text", "")))
+ if t.strip():
+ result.append(RenderBlock(
+ block_type="heading_2",
+ css_class="hb-heading-2",
+ data={"text": t},
+ ))
+
+ elif btype == "bullets":
+ items = b.get("items", [])
+ if not isinstance(items, list):
+ items = []
+ normalized = [_normalize_text_content(str(it).strip()) for it in items if str(it).strip()]
+ html_items = [Markup(emphasize_keywords(it)) for it in normalized]
+ if normalized:
+ result.append(RenderBlock(
+ block_type="bullet_list",
+ css_class="hb-bullet-list",
+ data={"entries": html_items, "html_entries": True},
+ ))
+
+ elif btype == "numbered_list":
+ items = b.get("items", [])
+ if not isinstance(items, list):
+ items = []
+ normalized = [_normalize_text_content(str(it).strip()) for it in items if str(it).strip()]
+ html_items = [Markup(emphasize_keywords(it)) for it in normalized]
+ if normalized:
+ result.append(RenderBlock(
+ block_type="bullet_list",
+ css_class="hb-bullet-list hb-numbered-list",
+ data={"entries": html_items, "ordered": True, "html_entries": True},
+ ))
+
+ elif btype == "note":
+ t = _normalize_text_content(str(b.get("text", "")))
+ if t.strip():
+ result.append(RenderBlock(
+ block_type="note",
+ css_class="hb-note",
+ data={"text": t},
+ ))
+
+ elif btype == "note_inline":
+ parts = b.get("parts", [])
+ if not isinstance(parts, list):
+ parts = []
+ normalized_parts = []
+ for p in parts:
+ if not isinstance(p, dict):
+ continue
+ t = _normalize_text_content(str(p.get("text", "")))
+ if t:
+ normalized_parts.append({
+ "text": t,
+ "style": str(p.get("style", "")),
+ })
+ if normalized_parts:
+ result.append(RenderBlock(
+ block_type="note",
+ css_class="hb-note",
+ data={"parts": normalized_parts, "inline": True},
+ ))
+
+ elif btype == "table_v1":
+ t_cols = b.get("columns", [])
+ t_rows = b.get("rows", [])
+ if not isinstance(t_cols, list):
+ t_cols = []
+ if not isinstance(t_rows, list):
+ t_rows = []
+ norm_rows = []
+ for r in t_rows:
+ if not isinstance(r, list):
+ continue
+ norm_rows.append([emphasize_keywords(_normalize_text_content(str(cell))) for cell in r])
+ result.append(RenderBlock(
+ block_type="table",
+ css_class="hb-table",
+ data={"columns": [str(c) for c in t_cols], "rows": norm_rows, "variant": "standard"},
+ ))
+
+ elif btype == "table":
+ # Generic table (columns may be objects or strings, rows may be dicts or lists)
+ t_cols = b.get("columns", [])
+ t_rows = b.get("rows", [])
+ if not isinstance(t_cols, list):
+ t_cols = []
+ if not isinstance(t_rows, list):
+ t_rows = []
+ col_labels = []
+ col_keys = []
+ for c in t_cols:
+ if isinstance(c, dict):
+ col_labels.append(str(c.get("label", c.get("key", ""))))
+ col_keys.append(str(c.get("key", "")))
+ else:
+ col_labels.append(str(c))
+ col_keys.append(re.sub(r"[^a-z0-9]+", "_", str(c).lower()))
+ norm_rows = []
+ for r in t_rows:
+ if isinstance(r, dict):
+ norm_rows.append([emphasize_keywords(_normalize_text_content(str(r.get(k, "")))) for k in col_keys])
+ elif isinstance(r, list):
+ norm_rows.append([emphasize_keywords(_normalize_text_content(str(cell))) for cell in r])
+ result.append(RenderBlock(
+ block_type="table",
+ css_class="hb-table",
+ data={"columns": col_labels, "rows": norm_rows, "variant": "standard"},
+ ))
+
+ elif btype in ("table_v3", "table_v4"):
+ t_rows = b.get("rows", [])
+ if not isinstance(t_rows, list):
+ t_rows = []
+ norm_rows = []
+ for r in t_rows:
+ if not isinstance(r, list):
+ continue
+ norm_row = []
+ for cell in r:
+ if isinstance(cell, dict):
+ norm_row.append({
+ "text": emphasize_keywords(_normalize_text_content(str(cell.get("text", "")))),
+ "colspan": int(cell.get("colspan", 1)) if str(cell.get("colspan", "")).isdigit() else 1,
+ "rowspan": int(cell.get("rowspan", 1)) if str(cell.get("rowspan", "")).isdigit() else 1,
+ })
+ else:
+ norm_row.append({
+ "text": emphasize_keywords(_normalize_text_content(str(cell))),
+ "colspan": 1,
+ "rowspan": 1,
+ })
+ norm_rows.append(norm_row)
+ result.append(RenderBlock(
+ block_type="table",
+ css_class="hb-table",
+ data={"rows": norm_rows, "variant": "spanning"},
+ ))
+
+ return result
diff --git a/app/services/pdf_renderer.py b/app/services/pdf_renderer.py
new file mode 100644
index 0000000000000000000000000000000000000000..dcb99a3e5ea0867e45a993341413b68fcd034f52
--- /dev/null
+++ b/app/services/pdf_renderer.py
@@ -0,0 +1,326 @@
+"""Playwright-based PDF renderer — Chromium headless PDF export.
+
+Replaces WeasyPrint. Uses Playwright to launch headless Chromium,
+load the fully-rendered HTML, wait for fonts/images/layout, and
+export a print-quality PDF.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Singleton browser instance for reuse across requests
+_browser = None
+_browser_lock = asyncio.Lock()
+
+
+async def _get_browser():
+ """Get or create a persistent Chromium browser instance.
+
+ Uses ``channel="chrome"`` so Playwright drives the system-installed
+ Google Chrome (or Chromium) instead of requiring a separate browser
+ download from the Playwright CDN. Falls back to the default
+ bundled Chromium if the system browser is not found.
+ """
+ global _browser
+ async with _browser_lock:
+ if _browser is None or not _browser.is_connected():
+ from playwright.async_api import async_playwright
+
+ pw = await async_playwright().start()
+
+ launch_args = [
+ "--no-sandbox",
+ "--disable-setuid-sandbox",
+ "--disable-dev-shm-usage",
+ "--disable-gpu",
+ "--font-render-hinting=none",
+ ]
+
+ # Try system Chrome first, then fall back to bundled Chromium
+ try:
+ _browser = await pw.chromium.launch(
+ channel="chrome",
+ headless=True,
+ args=launch_args,
+ )
+ logger.info("System Chrome launched for PDF rendering")
+ except Exception:
+ logger.warning(
+ "System Chrome not available, falling back to bundled Chromium"
+ )
+ _browser = await pw.chromium.launch(
+ headless=True,
+ args=launch_args,
+ )
+ logger.info("Bundled Chromium launched for PDF rendering")
+ return _browser
+
+
+async def shutdown_browser():
+ """Gracefully close the browser on application shutdown."""
+ global _browser
+ async with _browser_lock:
+ if _browser and _browser.is_connected():
+ await _browser.close()
+ _browser = None
+ logger.info("Chromium browser closed")
+
+
+async def render_pdf_from_html(
+ html_content: str,
+ *,
+ format: str = "A4",
+ print_background: bool = True,
+ prefer_css_page_size: bool = True,
+ wait_timeout: int = 30000,
+) -> bytes:
+ """Render HTML string to PDF bytes using Playwright Chromium.
+
+ Generates a base PDF (content only, no decorative header/label),
+ then creates a one-page overlay with the header image and right-side
+ label, and stamps the overlay onto content pages (page 3 → last
+ content page) using pypdf. Pages 1-2 (cover/TOC) and trailing
+ full-page image pages get no overlay.
+
+ Args:
+ html_content: Complete HTML document string.
+ format: Page format (default A4).
+ print_background: Include background colors/images.
+ prefer_css_page_size: Use @page CSS rules for sizing.
+ wait_timeout: Max time (ms) to wait for page load.
+
+ Returns:
+ PDF file bytes.
+ """
+ browser = await _get_browser()
+ context = await browser.new_context(
+ viewport={"width": 794, "height": 1123}, # A4 at 96dpi
+ device_scale_factor=1,
+ java_script_enabled=True,
+ )
+ page = await context.new_page()
+
+ try:
+ # Write HTML to a temp file so Chromium can load local file:// resources
+ with tempfile.NamedTemporaryFile(
+ mode="w",
+ suffix=".html",
+ delete=False,
+ encoding="utf-8",
+ ) as tmp:
+ tmp.write(html_content)
+ tmp_path = tmp.name
+
+ try:
+ file_url = Path(tmp_path).as_uri()
+ await page.goto(file_url, wait_until="load", timeout=wait_timeout)
+
+ # Wait for fonts and images to be fully loaded
+ await page.evaluate("() => document.fonts.ready")
+ await page.evaluate("""
+ () => {
+ const images = Array.from(document.querySelectorAll('img'));
+ return Promise.all(images.map(img => {
+ if (img.complete) return Promise.resolve();
+ return new Promise(r => {
+ img.addEventListener('load', r);
+ img.addEventListener('error', r);
+ });
+ }));
+ }
+ """)
+
+ # ── Collect info from DOM before hiding elements ──
+ header_src = await page.evaluate("""
+ () => {
+ const img = document.querySelector('.page-header img');
+ return img ? img.src : '';
+ }
+ """)
+ label_src = await page.evaluate("""
+ () => {
+ const img = document.querySelector('.hb-right-label img');
+ return img ? img.src : '';
+ }
+ """)
+ num_bottom_pages = await page.evaluate("""
+ () => document.querySelectorAll('.fullpage-img-wrap').length
+ """)
+ # Cover page count: cover + TOC image (each is a .cover-page)
+ num_cover_pages = await page.evaluate("""
+ () => document.querySelectorAll('.cover-page').length
+ """)
+
+ logger.info(
+ "Overlay info: header=%s, label=%s, covers=%d, bottoms=%d",
+ bool(header_src), bool(label_src),
+ num_cover_pages, num_bottom_pages,
+ )
+
+ # ── Hide header, footer, and label from the base PDF ──
+ await page.evaluate("""
+ () => {
+ document.querySelectorAll('.page-header, .page-footer, .hb-right-label')
+ .forEach(el => el.style.display = 'none');
+ }
+ """)
+
+ # ── Render BASE PDF (no header, no label) ──
+ base_pdf = await page.pdf(
+ format=format,
+ print_background=print_background,
+ prefer_css_page_size=prefer_css_page_size,
+ margin={
+ "top": "2.54cm",
+ "right": "2.54cm",
+ "bottom": "2.54cm",
+ "left": "2.54cm",
+ },
+ display_header_footer=True,
+ header_template='',
+ footer_template=(
+ '
'
+ '
'
+ ),
+ )
+ logger.info("Base PDF rendered, size=%d bytes", len(base_pdf))
+
+ finally:
+ os.unlink(tmp_path)
+
+ # ── Build overlay (header + label) and stamp onto content pages ──
+ if not header_src and not label_src:
+ logger.info("No header or label to overlay, returning base PDF")
+ return base_pdf
+
+ overlay_pdf = await _build_overlay_pdf(
+ page, header_src, label_src, format, wait_timeout
+ )
+
+ merged = _stamp_overlay(
+ base_pdf, overlay_pdf,
+ skip_front=num_cover_pages,
+ skip_back=num_bottom_pages,
+ )
+ logger.info("Final PDF with overlay, size=%d bytes", len(merged))
+ return merged
+
+ finally:
+ await context.close()
+
+
+async def _build_overlay_pdf(
+ page, header_src: str, label_src: str,
+ format: str, timeout: int,
+) -> bytes:
+ """Render a single-page transparent overlay PDF with header + label."""
+ parts = []
+ if header_src:
+ parts.append(
+ f'
'
+ f'
'
+ )
+ if label_src:
+ # Word doc: 3.0cm × 22.7cm container, ~0.35cm bleeds past right edge.
+ # Scaled proportionally to A4: 2.9cm × 24.1cm, right:-0.3cm to
+ # let part bleed off-page just like the Word original.
+ parts.append(
+ f'
'
+ f'
'
+ )
+
+ overlay_html = (
+ ''
+ ''
+ + '\n'.join(parts)
+ + ''
+ ''
+ )
+
+ with tempfile.NamedTemporaryFile(
+ mode="w", suffix=".html", delete=False, encoding="utf-8",
+ ) as tmp:
+ tmp.write(overlay_html)
+ tmp_path = tmp.name
+
+ try:
+ await page.goto(
+ Path(tmp_path).as_uri(),
+ wait_until="load",
+ timeout=timeout,
+ )
+ await page.evaluate("() => document.fonts.ready")
+ await page.evaluate("""
+ () => {
+ const images = Array.from(document.querySelectorAll('img'));
+ return Promise.all(images.map(img => {
+ if (img.complete) return Promise.resolve();
+ return new Promise(r => {
+ img.addEventListener('load', r);
+ img.addEventListener('error', r);
+ });
+ }));
+ }
+ """)
+
+ overlay_bytes = await page.pdf(
+ format=format,
+ print_background=True,
+ prefer_css_page_size=True,
+ margin={"top": "0", "right": "0", "bottom": "0", "left": "0"},
+ display_header_footer=False,
+ )
+ logger.info("Overlay PDF rendered, size=%d bytes", len(overlay_bytes))
+ return overlay_bytes
+ finally:
+ os.unlink(tmp_path)
+
+
+def _stamp_overlay(
+ base_pdf: bytes,
+ overlay_pdf: bytes,
+ skip_front: int = 2,
+ skip_back: int = 4,
+) -> bytes:
+ """Merge overlay onto content pages of the base PDF.
+
+ Pages 0..(skip_front-1) and (total-skip_back)..(total-1) are left
+ untouched. All other pages get the overlay stamped on top.
+ """
+ import io
+ from pypdf import PdfReader, PdfWriter
+
+ base = PdfReader(io.BytesIO(base_pdf))
+ overlay_reader = PdfReader(io.BytesIO(overlay_pdf))
+ overlay_page = overlay_reader.pages[0]
+ writer = PdfWriter()
+
+ total = len(base.pages)
+ first_content = skip_front # e.g. page index 2
+ last_content = total - skip_back - 1 # e.g. total-5
+
+ for i, pg in enumerate(base.pages):
+ if first_content <= i <= last_content:
+ pg.merge_page(overlay_page)
+ writer.add_page(pg)
+
+ buf = io.BytesIO()
+ writer.write(buf)
+ return buf.getvalue()
diff --git a/app/services/pdf_service.py b/app/services/pdf_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fceed01fa8be01805cd3461d28538e2e237a1ea
--- /dev/null
+++ b/app/services/pdf_service.py
@@ -0,0 +1,213 @@
+"""PDF generation service — Playwright Chromium PDF export.
+
+Uses headless Chromium via Playwright to render the handbook HTML
+and export a print-quality PDF. Replaces the previous WeasyPrint
+approach for better CSS support and visual fidelity.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# No in-memory cache — every request fetches fresh data from the database
+
+
+def _get_images_config() -> dict[str, Any]:
+ """Build images config from the images directory.
+
+ Mirrors PHP getImagesConfig().
+ """
+ from app.core.config import get_settings
+
+ settings = get_settings()
+ images_dir = os.path.realpath(settings.images_dir)
+
+ if not os.path.isdir(images_dir):
+ raise RuntimeError(f"Handbook images directory not found: {images_dir}")
+
+ cover_image = os.path.join(images_dir, "first_page.jpg")
+ toc_image = os.path.join(images_dir, "toc.jpg")
+ header_image = os.path.join(images_dir, "kenya_airlift_header.jpg")
+ label_image = os.path.join(images_dir, "label.png")
+
+ # Auto-discover bottom page images (sorted by filename, prefer .jpg over .png dupes)
+ _bottom_candidates = sorted(
+ f for f in os.listdir(images_dir)
+ if f.lower().endswith((".jpg", ".png"))
+ and "page-000" in f
+ and f != "first_page.jpg"
+ )
+ # Deduplicate: if both .jpg and .png exist for same stem, keep .jpg
+ _seen_stems: set[str] = set()
+ bottom_pages: list[str] = []
+ for f in _bottom_candidates:
+ stem = os.path.splitext(f)[0]
+ if stem in _seen_stems:
+ continue
+ _seen_stems.add(stem)
+ bottom_pages.append(os.path.join(images_dir, f))
+
+ # Validate required images exist
+ required = [cover_image, toc_image, header_image, label_image] + bottom_pages
+ missing = [p for p in required if not os.path.isfile(p)]
+ if missing:
+ logger.warning("Missing handbook images: %s", missing)
+ # Don't crash — generate with what we have
+
+ return {
+ "imagesDir": images_dir,
+ "chroot": os.path.dirname(images_dir),
+ "coverImage": cover_image if os.path.isfile(cover_image) else "",
+ "tocImage": toc_image if os.path.isfile(toc_image) else "",
+ "headerImage": header_image if os.path.isfile(header_image) else "",
+ "labelImage": label_image if os.path.isfile(label_image) else "",
+ "bottomPages": [p for p in bottom_pages if os.path.isfile(p)],
+ "httpsBaseHandbook": "",
+ }
+
+
+def render_pdf(html: str) -> bytes:
+ """Render HTML to PDF bytes using Playwright Chromium.
+
+ This is a synchronous wrapper around the async Playwright renderer.
+ For async contexts, use render_pdf_async() instead.
+ """
+ import asyncio
+
+ try:
+ loop = asyncio.get_running_loop()
+ except RuntimeError:
+ loop = None
+
+ if loop and loop.is_running():
+ # Already in an async context — create a new task
+ import concurrent.futures
+ with concurrent.futures.ThreadPoolExecutor() as pool:
+ future = pool.submit(asyncio.run, _render_pdf_async(html))
+ return future.result()
+ else:
+ return asyncio.run(_render_pdf_async(html))
+
+
+async def _render_pdf_async(html: str) -> bytes:
+ """Async: render HTML to PDF bytes via Playwright Chromium."""
+ from app.services.pdf_renderer import render_pdf_from_html
+ return await render_pdf_from_html(html)
+
+
+async def generate_handbook_pdf(
+ catalog_id: int = 0,
+ include_inactive_programs: bool = False,
+ debug: bool = False,
+) -> bytes:
+ """Full pipeline: fetch data -> Jinja2 HTML -> Playwright Chromium -> PDF.
+
+ Mirrors the PHP download.php flow with Playwright as the rendering engine.
+
+ Optimizations over the naive sequential approach:
+ - Parallel API fetches (global + university sections concurrently)
+ - Parallel campus image prefetching (async batch instead of serial)
+ """
+ from app.services.data_fetcher import fetch_global_sections, fetch_university_sections
+ from app.services.html_builder import build_handbook_html
+ from app.services.pdf_renderer import render_pdf_from_html
+ from app.services.renderers import prefetch_images
+
+ images = _get_images_config()
+
+ # Fetch global sections and university sections in parallel
+ globals_data, by_uni = await asyncio.gather(
+ fetch_global_sections(catalog_id),
+ fetch_university_sections(),
+ )
+
+ # Collect all campus image URLs and prefetch them in parallel
+ campus_urls: list[str] = []
+ for uid, uni in by_uni.items():
+ if not isinstance(uni, dict):
+ continue
+ sections = uni.get("sections", [])
+ if not isinstance(sections, list):
+ continue
+ for s in sections:
+ if not isinstance(s, dict):
+ continue
+ k = str(s.get("section_key", ""))
+ if k in ("campus_image", "image"):
+ j = s.get("section_json", {})
+ if isinstance(j, dict):
+ url = str(j.get("image_url", "")).strip()
+ if url:
+ campus_urls.append(url)
+
+ if campus_urls:
+ await prefetch_images(campus_urls)
+
+ html = build_handbook_html(
+ globals_data,
+ by_uni,
+ images,
+ allow_remote=True,
+ include_inactive_programs=include_inactive_programs,
+ debug=debug,
+ )
+
+ pdf_bytes = await render_pdf_from_html(html)
+
+ return pdf_bytes
+
+
+async def generate_handbook_html(
+ catalog_id: int = 0,
+ include_inactive_programs: bool = False,
+ debug: bool = False,
+) -> str:
+ """Full pipeline: fetch data -> Jinja2 HTML (no PDF conversion)."""
+ from app.services.data_fetcher import fetch_global_sections, fetch_university_sections
+ from app.services.html_builder import build_handbook_html
+ from app.services.renderers import prefetch_images
+
+ images = _get_images_config()
+
+ globals_data, by_uni = await asyncio.gather(
+ fetch_global_sections(catalog_id),
+ fetch_university_sections(),
+ )
+
+ # Prefetch campus images in parallel for the HTML build
+ campus_urls: list[str] = []
+ for uid, uni in by_uni.items():
+ if not isinstance(uni, dict):
+ continue
+ sections = uni.get("sections", [])
+ if not isinstance(sections, list):
+ continue
+ for s in sections:
+ if not isinstance(s, dict):
+ continue
+ k = str(s.get("section_key", ""))
+ if k in ("campus_image", "image"):
+ j = s.get("section_json", {})
+ if isinstance(j, dict):
+ url = str(j.get("image_url", "")).strip()
+ if url:
+ campus_urls.append(url)
+
+ if campus_urls:
+ await prefetch_images(campus_urls)
+
+ return build_handbook_html(
+ globals_data,
+ by_uni,
+ images,
+ allow_remote=True,
+ include_inactive_programs=include_inactive_programs,
+ debug=debug,
+ )
diff --git a/app/services/renderers.py b/app/services/renderers.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f795e226248e019479daf36b085790509c861cf
--- /dev/null
+++ b/app/services/renderers.py
@@ -0,0 +1,1097 @@
+"""Renderers — mirrors PHP renderers.php.
+
+Contains functions for rendering:
+- Table of Contents (TOC)
+- Global section blocks (overview, steps, bullets, tables, doc_v1, etc.)
+- University section blocks (overview, benefits, programs)
+- Remote image fetching as data URIs
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import re
+from typing import Any
+
+import httpx
+
+from app.services.utils import (
+ emphasize_keywords,
+ format_money_figures,
+ get_any,
+ h,
+ hb_slug,
+ is_assoc,
+ is_truthy,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# =========================================
+# Image fetching (with in-memory cache + async batch support)
+# =========================================
+
+_image_cache: dict[str, str] = {}
+
+
+def _detect_image_mime(data: bytes, content_type: str) -> str:
+ """Detect image MIME type from headers or magic bytes."""
+ if "image/" in content_type:
+ return content_type.split(";")[0].strip()
+ if data[:8].startswith(b"\x89PNG"):
+ return "image/png"
+ if data[:3] == b"\xff\xd8\xff":
+ return "image/jpeg"
+ if data[:4] == b"GIF8":
+ return "image/gif"
+ if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+ return "image/webp"
+ return ""
+
+
+def fetch_image_data_uri(url: str) -> str:
+ """Fetch a remote image and return as data:... URI. Mirrors PHP fetchImageDataUri."""
+ url = url.strip()
+ if not url:
+ return ""
+
+ # Check cache first (populated by prefetch_images)
+ if url in _image_cache:
+ return _image_cache[url]
+
+ try:
+ with httpx.Client(verify=False, timeout=12, follow_redirects=True) as client:
+ resp = client.get(url)
+ if resp.status_code < 200 or resp.status_code >= 300 or not resp.content:
+ logger.warning("Image fetch failed for %s status=%d", url, resp.status_code)
+ _image_cache[url] = ""
+ return ""
+ data = resp.content
+ except Exception as exc:
+ logger.warning("Image fetch error for %s: %s", url, exc)
+ _image_cache[url] = ""
+ return ""
+
+ mime = _detect_image_mime(data, resp.headers.get("content-type", ""))
+ if not mime.startswith("image/"):
+ logger.warning("Invalid image mime %s for %s", mime, url)
+ _image_cache[url] = ""
+ return ""
+
+ b64 = base64.b64encode(data).decode("ascii")
+ result = f"data:{mime};base64,{b64}"
+ _image_cache[url] = result
+ return result
+
+
+async def prefetch_images(urls: list[str]) -> dict[str, str]:
+ """Fetch all images in parallel using async HTTP and populate the cache.
+
+ This is the key optimization: instead of fetching ~30 campus images
+ serially (30-60s), we fetch them all concurrently (~3-5s).
+ """
+ import asyncio
+
+ unique_urls = list({u.strip() for u in urls if u.strip() and u.strip() not in _image_cache})
+ if not unique_urls:
+ return {u: _image_cache.get(u.strip(), "") for u in urls}
+
+ async def _fetch_one(client: httpx.AsyncClient, url: str) -> tuple[str, str]:
+ try:
+ resp = await client.get(url)
+ if resp.status_code < 200 or resp.status_code >= 300 or not resp.content:
+ logger.warning("Prefetch image failed for %s status=%d", url, resp.status_code)
+ return url, ""
+ mime = _detect_image_mime(resp.content, resp.headers.get("content-type", ""))
+ if not mime.startswith("image/"):
+ logger.warning("Prefetch invalid mime %s for %s", mime, url)
+ return url, ""
+ b64 = base64.b64encode(resp.content).decode("ascii")
+ return url, f"data:{mime};base64,{b64}"
+ except Exception as exc:
+ logger.warning("Prefetch image error for %s: %s", url, exc)
+ return url, ""
+
+ logger.info("Prefetching %d campus images in parallel...", len(unique_urls))
+ async with httpx.AsyncClient(verify=False, timeout=15, follow_redirects=True) as client:
+ results = await asyncio.gather(*[_fetch_one(client, u) for u in unique_urls])
+
+ fetched = 0
+ for url, data_uri in results:
+ _image_cache[url] = data_uri
+ if data_uri:
+ fetched += 1
+
+ logger.info("Prefetched %d/%d images successfully", fetched, len(unique_urls))
+ return {u: _image_cache.get(u.strip(), "") for u in urls}
+
+
+# =========================================
+# Funding extraction
+# =========================================
+
+def _extract_university_funding(
+ j: dict,
+ school_meta: dict | None = None,
+) -> tuple[str, list[str]]:
+ """Extract funding heading + items from benefits section JSON.
+
+ Priority:
+ 1. section_json.funding.options
+ 2. section_json.funding_available
+ 3. fallback from pth_ref_schools.school_category
+ """
+ if not isinstance(j, dict):
+ j = {}
+
+ heading = "Funding Available"
+ items: list[str] = []
+
+ # 1. Preferred normalized shape
+ funding = j.get("funding", {})
+ if isinstance(funding, dict):
+ subheading = str(funding.get("subheading", "")).strip()
+ if subheading:
+ heading = subheading
+
+ options = funding.get("options", [])
+ if isinstance(options, list):
+ for opt in options:
+ if not isinstance(opt, dict):
+ continue
+ name = str(opt.get("name", "")).strip()
+ amount = str(opt.get("amount", "")).strip()
+
+ if name and amount:
+ items.append(f"{name} - {amount}")
+ elif name:
+ items.append(name)
+ elif amount:
+ items.append(amount)
+
+ # 2. Legacy fallback shape
+ if not items:
+ funding_available = j.get("funding_available", [])
+ if isinstance(funding_available, list):
+ for item in funding_available:
+ text = str(item).strip()
+ if text:
+ items.append(text)
+
+ # 3. School-category fallback
+ if not items and isinstance(school_meta, dict):
+ school_category = str(school_meta.get("school_category", "")).strip().lower()
+ status = str(school_meta.get("status", "")).strip().lower()
+
+ if status == "in":
+ if school_category == "non_cosigner":
+ items = [
+ "ISP Study Loan - $10,000",
+ "Partner 1 (Unsecured Loan) - Up to $50,000 per academic year",
+ "Partner 3 (Credit Option) - Up to $15,000",
+ ]
+ elif school_category == "cosigner":
+ items = [
+ "ISP Study Loan - $10,000",
+ "Partner 2 (A Cosigned Loan) - Full Coverage Support",
+ "Partner 3 (Credit Option) - Up to $15,000",
+ ]
+
+ return (heading, items)
+
+
+# =========================================
+# TOC sorting and rendering
+# =========================================
+
+def sort_toc(items: list[dict]) -> list[dict]:
+ """Mirrors PHP sortHandbookToc — sort by sort_order/sort, stable fallback."""
+ for idx, e in enumerate(items):
+ e.setdefault("_i", idx)
+
+ def key_fn(e: dict):
+ so = e.get("sort_order", e.get("sort"))
+ if so is not None:
+ try:
+ so_num = float(so)
+ return (0, so_num, e.get("_i", 0))
+ except (ValueError, TypeError):
+ pass
+ return (1, 0.0, e.get("_i", 0))
+
+ items.sort(key=key_fn)
+ for e in items:
+ e.pop("_i", None)
+ return items
+
+
+def render_toc(items: list[dict], debug: bool = False, show_pages: bool = True) -> str:
+ """Render Table of Contents HTML (DOMPDF-safe).
+
+ Mirrors PHP renderToc().
+ """
+ sorted_items = sort_toc(items)
+
+ out = ''
+ out += '
'
+ out += '
Table of Contents
'
+ out += (
+ '
'
+ '
'
+ )
+
+ for e in sorted_items:
+ if not isinstance(e, dict):
+ continue
+ title = str(e.get("title", "")).strip()
+ target = str(e.get("target", e.get("anchor", ""))).strip()
+ if not title:
+ continue
+
+ level = max(0, min(3, int(e.get("level", 0))))
+ bold = bool(e.get("bold", False))
+ upper = bool(e.get("upper", False))
+ if level == 0:
+ bold = True
+ upper = True
+
+ row_class = "toc-row--major" if level == 0 else "toc-row--sub"
+ if level >= 2:
+ row_class += " toc-row--deep"
+
+ text = title.upper() if upper else title
+ title_inner = h(text)
+ if target:
+ title_inner = f'{title_inner}'
+ if bold:
+ title_inner = f"{title_inner}"
+
+ page = str(e.get("page", "")).strip()
+ if show_pages and page:
+ page_cell = f"{h(page)}"
+ else:
+ page_cell = " "
+
+ indent = ""
+ if level == 1:
+ indent = "padding-left:16px;"
+ elif level >= 2:
+ indent = "padding-left:30px;"
+
+ title_style = (
+ "vertical-align:bottom; padding:1px 4px 1px 0; font-size:10px; "
+ "line-height:1.15; color:#111;"
+ + (" font-weight:700;" if bold else " font-weight:400;")
+ + (" text-transform:uppercase; letter-spacing:0.1px;" if upper else "")
+ + (f" {indent}" if indent else "")
+ )
+
+ out += f'
'
+ out += f'
{title_inner}
'
+ out += '
'
+ out += (
+ f'
{page_cell}
'
+ )
+ out += "
"
+
+ out += "
"
+ return out
+
+
+def render_toc_hardcoded(
+ items: list[dict],
+ debug: bool = False,
+ page_start: int = 3,
+ page_offset: int = 0,
+) -> str:
+ """Mirrors PHP renderTocHardcoded — sort, assign sequential pages, render."""
+ sorted_items = sort_toc(items)
+
+ seq = max(1, page_start)
+ for item in sorted_items:
+ p = str(item.get("page", "")).strip()
+ if p and p.lstrip("-").isdigit():
+ display = int(p) + page_offset
+ item["page"] = str(display)
+ if display >= seq:
+ seq = display + 1
+ else:
+ item["page"] = str(seq)
+ seq += 1
+
+ out = "\n"
+ out += '
'
+ out += '
Table of Contents
'
+ out += (
+ '
'
+ '
'
+ )
+
+ for e in sorted_items:
+ if not isinstance(e, dict):
+ continue
+ title = str(e.get("title", "")).strip()
+ target = str(e.get("target", e.get("anchor", ""))).strip()
+ if not title:
+ continue
+
+ level = max(0, min(3, int(e.get("level", 0))))
+ bold = bool(e.get("bold", False))
+ upper = bool(e.get("upper", False))
+ if level == 0:
+ bold = True
+ upper = True
+
+ row_class = "toc-row--major" if level == 0 else "toc-row--sub"
+ if level >= 2:
+ row_class += " toc-row--deep"
+
+ text = title.upper() if upper else title
+ title_inner = h(text)
+ if target:
+ title_inner = f'{title_inner}'
+ if bold:
+ title_inner = f"{title_inner}"
+
+ page = str(e.get("page", "")).strip()
+ page_html = f"{h(page)}" if page else " "
+
+ indent = ""
+ if level == 1:
+ indent = "padding-left:16px;"
+ elif level >= 2:
+ indent = "padding-left:30px;"
+
+ title_style = (
+ "vertical-align:bottom;padding:1px 4px 1px 0;font-size:10px;"
+ "line-height:1.15;color:#111;"
+ + ("font-weight:700;" if bold else "font-weight:400;")
+ + ("text-transform:uppercase;letter-spacing:0.1px;" if upper else "")
+ + indent
+ )
+
+ out += f'
'
+ out += f'
{title_inner}
'
+ out += '
'
+ out += (
+ f'
{page_html}
'
+ )
+ out += "
"
+
+ out += "
"
+ return out
+
+
+# =========================================
+# table_v3 / table_v4 cell helpers
+# =========================================
+
+# Mapping of style names → inline CSS strings for table_v3/v4 cells
+_V3_STYLE_MAP: dict[str, str] = {
+ "band_teal": "text-align:center;font-weight:700;color:#fff;background:#199970;",
+ "band_navy": "text-align:center;font-weight:700;color:#fff;background:#0263A3;",
+ "bold_amounts": "font-weight:600;",
+ "green_center_bold": "text-align:center;font-weight:700;color:#199970;",
+ "center_bold_multiline": "text-align:center;font-weight:600;vertical-align:middle;",
+ "footer_center_bold": "text-align:center;font-weight:700;background:#f5f5f5;",
+ "covered_merged": "vertical-align:top;font-size:9pt;line-height:1.5;",
+}
+
+
+def _parse_v3_cell(cell: Any) -> tuple[str, str, str]:
+ """Parse a table_v3/v4 cell dict into (attr_str, style_str, html_content)."""
+ if not isinstance(cell, dict):
+ text = format_money_figures(str(cell)) if cell else ""
+ return ("", "", h(text))
+
+ colspan = 1
+ rowspan = 1
+ text_val = str(cell.get("text", ""))
+ cs = cell.get("colspan")
+ rs = cell.get("rowspan")
+ if cs is not None and str(cs).isdigit():
+ colspan = int(cs)
+ if rs is not None and str(rs).isdigit():
+ rowspan = int(rs)
+
+ attr = ""
+ if colspan > 1:
+ attr += f' colspan="{colspan}"'
+ if rowspan > 1:
+ attr += f' rowspan="{rowspan}"'
+
+ style_name = str(cell.get("style", ""))
+ inline_css = _V3_STYLE_MAP.get(style_name, "")
+ style_str = f' style="{inline_css}"' if inline_css else ""
+
+ # Rich parts within cell (merged cells with multiple text blocks)
+ parts = cell.get("parts")
+ if isinstance(parts, list) and parts:
+ html_parts: list[str] = []
+ for p in parts:
+ if not isinstance(p, dict):
+ continue
+ pt = format_money_figures(str(p.get("text", "")))
+ if not pt:
+ continue
+ if p.get("bold"):
+ html_parts.append(f"{h(pt)}")
+ else:
+ html_parts.append(h(pt))
+ content = "
".join(html_parts) if html_parts else h(format_money_figures(text_val))
+ else:
+ content = h(format_money_figures(text_val))
+
+ return (attr, style_str, content)
+
+
+# =========================================
+# Global blocks renderer
+# =========================================
+
+def render_global_blocks(
+ section_key: str,
+ section_title: str,
+ json_data: dict | list,
+ debug: bool = False,
+ *,
+ universities: list[dict] | None = None,
+) -> str:
+ """Render a single global section's content.
+
+ Mirrors PHP renderGlobalBlocks() — handles steps, bullets, tables,
+ doc_v1, table_v2, summary_of_universities, etc.
+ """
+ html_out = ""
+ key_norm = section_key.lower().strip()
+
+ if not isinstance(json_data, dict):
+ json_data = {}
+
+ layout_norm = str(json_data.get("layout", "")).lower().strip()
+
+ # ── Section title ──
+ # Prefer the JSON-level title (display-ready) over the DB section_title
+ json_title = str(json_data.get("title", "")).strip() if isinstance(json_data, dict) else ""
+ title = json_title or section_title.strip()
+ if title and key_norm != "table_of_contents":
+ html_out += f'
{h(title)}
'
+ _title_norm = title.lower()
+
+ # ── Steps ──
+ steps = json_data.get("steps")
+ if isinstance(steps, list):
+ step_num = 0
+ for s in steps:
+ if not isinstance(s, dict):
+ continue
+ step_num += 1
+ step_title = str(s.get("title", s.get("step_title", ""))).strip()
+ body = format_money_figures(str(s.get("body", s.get("description", ""))).strip())
+
+ html_out += '
'
+ if step_title:
+ html_out += f'
Step {step_num}: {h(step_title)}
'
+ if body:
+ html_out += f'
{emphasize_keywords(body)}
'
+
+ links = s.get("links", [])
+ if isinstance(links, list) and links:
+ html_out += '
'
+ for lnk in links:
+ if not isinstance(lnk, dict):
+ continue
+ label = str(lnk.get("label", "Link")).strip()
+ url = str(lnk.get("url", "")).strip()
+ if not url:
+ continue
+ html_out += f'
"
+ for c in base_cols:
+ if isinstance(c, dict):
+ html_out += f'
{h(str(c.get("label", "")))}
'
+ for g in groups:
+ if not isinstance(g, dict):
+ continue
+ g_cols = g.get("columns", [])
+ if not isinstance(g_cols, list):
+ g_cols = []
+ span = max(1, len(g_cols))
+ html_out += f'
{h(str(g.get("label", "")))}
'
+ html_out += "
"
+ for g in groups:
+ if not isinstance(g, dict):
+ continue
+ g_cols = g.get("columns", [])
+ if not isinstance(g_cols, list):
+ g_cols = []
+ for c in g_cols:
+ if isinstance(c, dict):
+ html_out += f'
{h(str(c.get("label", "")))}
'
+ html_out += "
"
+ else:
+ html_out += "
"
+ for c in all_cols:
+ html_out += f'
{h(c.get("label", ""))}
'
+ html_out += "
"
+
+ html_out += ""
+ for r in rows:
+ if not isinstance(r, dict):
+ continue
+ html_out += "
"
+ for c in all_cols:
+ k = c.get("key", "")
+ val = r.get(k, "")
+ if isinstance(val, dict):
+ val = val.get("text", "")
+ html_out += f"
{h(format_money_figures(str(val)))}
"
+ html_out += "
"
+ html_out += "
"
+ return html_out
+
+ # ── doc_v1 ──
+ if layout_norm == "doc_v1" and isinstance(json_data.get("blocks"), list):
+ for b in json_data["blocks"]:
+ if not isinstance(b, dict):
+ continue
+ btype = str(b.get("type", ""))
+
+ # Skip heading/subheading blocks that duplicate the section title
+ if btype in ("heading", "subheading"):
+ block_text = str(b.get("text", "")).strip().lower()
+ if block_text == _title_norm:
+ continue
+
+ if btype == "paragraph":
+ t = format_money_figures(str(b.get("text", "")))
+ if t.strip():
+ html_out += f'
{emphasize_keywords(t)}
'
+
+ elif btype == "subheading":
+ t = format_money_figures(str(b.get("text", "")))
+ if t.strip():
+ html_out += f'
"
+ )
+
+ # 4. Benefits
+ if "benefits" in sec_map:
+ j = sec_map["benefits"].get("section_json", {})
+ if not isinstance(j, dict):
+ j = {}
+ benefits = j.get("benefits", [])
+ if not isinstance(benefits, list):
+ benefits = []
+
+ out += '
'
+ out += '
Benefits for ISP students at this school
'
+ if benefits:
+ out += '
'
+ for b in benefits:
+ b_str = str(b).strip()
+ if not b_str:
+ continue
+ out += f'
•{h(b_str)}
'
+ out += "
"
+ else:
+ out += '
No benefits listed.
'
+ out += "
"
+
+ # 5. Programs
+ if "programs" in sec_map:
+ j = sec_map["programs"].get("section_json", {})
+ if not isinstance(j, dict):
+ j = {}
+ programs = j.get("programs", [])
+ if not isinstance(programs, list):
+ programs = []
+
+ # Filter inactive
+ if not include_inactive_programs:
+ def _is_active(p: dict) -> bool:
+ flag = p.get("program_active", p.get("is_active", p.get("active", 1)))
+ return is_truthy(flag)
+
+ programs = [p for p in programs if isinstance(p, dict) and _is_active(p)]
+
+ out += (
+ '
To qualify for The International Scholars Program at '
+ f"{h(uni_name)}, you must be willing to study any of the following programs:
"
+ )
+
+ if programs:
+ out += '
'
+ out += (
+ '
Program
'
+ '
Designation
'
+ '
Entrance Examination
'
+ )
+
+ for p in programs:
+ if not isinstance(p, dict):
+ continue
+
+ program_name = str(p.get("program_name", "")).strip()
+ link = str(p.get("program_link", "")).strip()
+ if not link and isinstance(p.get("program_links"), dict):
+ link = str(p["program_links"].get("web_link", "")).strip()
+
+ program_name_html = h(program_name)
+ if link:
+ program_name_html = f'{program_name_html}'
+
+
+
+ entrance = str(p.get("entrance_exam", p.get("entrance_examination", "")))
+ designation = str(p.get("designation", ""))
+ out += (
+ f"
"
+ f"
{program_name_html}
"
+ f"
{h(designation)}
"
+ f"
{h(entrance)}
"
+ f"
"
+ )
+
+ out += "
"
+ else:
+ out += '
No programs listed.
'
+
+ # Extra sections
+ skip_keys = {"campus_image", "image", "overview", "benefits", "programs"}
+ for s in sections:
+ if not isinstance(s, dict):
+ continue
+ k = str(s.get("section_key", ""))
+ if not k or k in skip_keys:
+ continue
+ title = str(s.get("section_title", ""))
+ j = s.get("section_json", {})
+ if not isinstance(j, dict):
+ j = {}
+ out += render_global_blocks(k, title, j, debug)
+
+ out += "
+
+ {# ── Dynamic TOC ── #}
+ {% if not toc_image and toc_items %}
+
+ {% include "partials/toc.html" %}
+
+ {% endif %}
+
+ {# ── Global Sections ── #}
+ {% for gs in general_sections %}
+
+ {% if gs.blocks %}
+ {% for block in gs.blocks %}
+ {% include "partials/blocks/render_block.html" %}
+ {% endfor %}
+ {% else %}
+ {{ gs.rendered_html }}
+ {% endif %}
+
+ {% endfor %}
+
+ {# ── Summary of Universities ── #}
+ {% if summary_block %}
+
+ {% if summary_block.blocks %}
+ {% for block in summary_block.blocks %}
+ {% include "partials/blocks/render_block.html" %}
+ {% endfor %}
+ {% else %}
+ {{ summary_block.rendered_html }}
+ {% endif %}
+
+ {% endif %}
+
+ {# ── University Sections (grouped by tier with divider headings) ── #}
+ {% if university_blocks %}
+ {% for block in university_blocks %}
+ {% include "partials/blocks/render_block.html" %}
+ {% endfor %}
+ {% elif universities %}
+ {% for uni in universities %}
+ {% if uni.tier_group_start and uni.tier_group_label %}
+
+ {% endif %}
+
+
+
+
\ No newline at end of file
diff --git a/app/templates/partials/blocks/bullet_list.html b/app/templates/partials/blocks/bullet_list.html
new file mode 100644
index 0000000000000000000000000000000000000000..8794dab32bab8938fc52e0c7c4bece3279de3b1f
--- /dev/null
+++ b/app/templates/partials/blocks/bullet_list.html
@@ -0,0 +1,22 @@
+{# Block partial: bullet_list (ordered or unordered) — supports HTML-formatted entries #}
+{% if block.data.ordered %}
+
+ {% for item in block.data.entries %}
+ {% if block.data.html_entries %}
+
{{ item }}
+ {% else %}
+
{{ item | e }}
+ {% endif %}
+ {% endfor %}
+
+{% else %}
+
+ {% for item in block.data.entries %}
+ {% if block.data.html_entries %}
+
{{ item }}
+ {% else %}
+
{{ item | e }}
+ {% endif %}
+ {% endfor %}
+
+{% endif %}
\ No newline at end of file
diff --git a/app/templates/partials/blocks/enrollment_steps.html b/app/templates/partials/blocks/enrollment_steps.html
new file mode 100644
index 0000000000000000000000000000000000000000..bab5da0f40a24778adb8048096f6caae0a658695
--- /dev/null
+++ b/app/templates/partials/blocks/enrollment_steps.html
@@ -0,0 +1,39 @@
+{# Block partial: enrollment_steps — each step visually separated #}
+{% for step in block.data.steps %}
+
This telegram group will help you interact with program administrators and other prospective
+ students where you can ask any questions you may have about the program.
+ {% endif %}
+
+{% endfor %}
\ No newline at end of file
diff --git a/app/templates/partials/blocks/heading.html b/app/templates/partials/blocks/heading.html
new file mode 100644
index 0000000000000000000000000000000000000000..39c4a4ae33cb7aad26e9dcf6d581d7945d994e98
--- /dev/null
+++ b/app/templates/partials/blocks/heading.html
@@ -0,0 +1,6 @@
+{# Block partial: heading_1 / heading_2 #}
+{% if block.block_type == 'heading_1' %}
+
{{ block.data.text | e }}
+{% elif block.block_type == 'heading_2' %}
+
{{ block.data.text | e }}
+{% endif %}
\ No newline at end of file
diff --git a/app/templates/partials/blocks/note.html b/app/templates/partials/blocks/note.html
new file mode 100644
index 0000000000000000000000000000000000000000..0dd8023543ddd6619930b7ddf249a96b8ece25d4
--- /dev/null
+++ b/app/templates/partials/blocks/note.html
@@ -0,0 +1,34 @@
+{# Block partial: note (standalone or inline-parts) #}
+{% if block.data.inline and block.data.parts %}
+
+ {% for part in block.data.parts %}
+ {% if part.style == 'red_bold' %}
+ {{ part.text | e }}
+ {% elif part.style == 'bold' %}
+ {{ part.text | e }}
+ {% elif part.style == 'italic' %}
+ {{ part.text | e }}
+ {% else %}
+ {{ part.text | e }}
+ {% endif %}
+ {% endfor %}
+
+{% else %}
+
+ {% set text = block.data.text | default('') %}
+ {# Highlight NOTE / ONLY IF keywords in bold + red; rest stays bold via CSS #}
+ {% if text.upper().startswith('NOTE:') %}
+ NOTE: {{ text[5:] | e }}
+ {% elif text.upper().startswith('NOTE ') %}
+ NOTE {{ text[4:] | e }}
+ {% elif text.upper().startswith('NOTE') %}
+ NOTE{{ text[4:] | e }}
+ {% elif text.upper().startswith('ONLY IF:') %}
+ ONLY IF: {{ text[8:] | e }}
+ {% elif text.upper().startswith('ONLY IF') %}
+ ONLY IF {{ text[7:] | e }}
+ {% else %}
+ {{ text | e }}
+ {% endif %}
+
+{% endif %}
\ No newline at end of file
diff --git a/app/templates/partials/blocks/paragraph.html b/app/templates/partials/blocks/paragraph.html
new file mode 100644
index 0000000000000000000000000000000000000000..25ab402d53207b365affe46b4376f98b7a3484f9
--- /dev/null
+++ b/app/templates/partials/blocks/paragraph.html
@@ -0,0 +1,6 @@
+{# Block partial: paragraph — supports pre-formatted HTML for bold emphasis #}
+{% if block.data.html %}
+
{{ block.data.html }}
+{% else %}
+
{{ block.data.text | e }}
+{% endif %}
\ No newline at end of file
diff --git a/app/templates/partials/blocks/render_block.html b/app/templates/partials/blocks/render_block.html
new file mode 100644
index 0000000000000000000000000000000000000000..4488f4425577cc70f8808954ad54013803a96876
--- /dev/null
+++ b/app/templates/partials/blocks/render_block.html
@@ -0,0 +1,18 @@
+{# Universal block dispatcher — renders any RenderBlock via its type-specific partial #}
+{% if block.block_type in ('heading_1', 'heading_2') %}
+{% include "partials/blocks/heading.html" %}
+{% elif block.block_type == 'paragraph' %}
+{% include "partials/blocks/paragraph.html" %}
+{% elif block.block_type == 'bullet_list' %}
+{% include "partials/blocks/bullet_list.html" %}
+{% elif block.block_type == 'note' %}
+{% include "partials/blocks/note.html" %}
+{% elif block.block_type == 'table' %}
+{% include "partials/blocks/table.html" %}
+{% elif block.block_type == 'enrollment_steps' %}
+{% include "partials/blocks/enrollment_steps.html" %}
+{% elif block.block_type == 'university_summary' %}
+{% include "partials/blocks/university_summary.html" %}
+{% elif block.block_type == 'school_profile' %}
+{% include "partials/blocks/school_profile.html" %}
+{% endif %}
\ No newline at end of file
diff --git a/app/templates/partials/blocks/school_profile.html b/app/templates/partials/blocks/school_profile.html
new file mode 100644
index 0000000000000000000000000000000000000000..d4a0091cf337dd201207f2a565a6d29daae61133
--- /dev/null
+++ b/app/templates/partials/blocks/school_profile.html
@@ -0,0 +1,122 @@
+{# Block partial: school_profile — full university page #}
+
+
+ {# ── University Title ── #}
+ {% if block.data.website %}
+
+ {% for col in block.data.columns %}
+ {% set col_lc = (col | lower) %}
+
{{
+ col | e }}
+ {% endfor %}
+
+
+ {% endif %}
+
+ {% for row in block.data.rows %}
+
+ {% for cell in row %}
+ {% set col = block.data.columns[loop.index0] if block.data.columns and loop.index0 < (block.data.columns |
+ length) else '' %} {% set col_lc=(col | lower) %}
{{
+ cell | safe }}
+ {% endfor %}
+
+ {% endfor %}
+
+
+{% endif %}
\ No newline at end of file
diff --git a/app/templates/partials/blocks/university_summary.html b/app/templates/partials/blocks/university_summary.html
new file mode 100644
index 0000000000000000000000000000000000000000..db229ddfe7c2ffe2142298b20f51cd364416cf00
--- /dev/null
+++ b/app/templates/partials/blocks/university_summary.html
@@ -0,0 +1,6 @@
+{# Block partial: university_summary — numbered list of universities #}
+
+ {% for name in block.data.universities %}
+
{{ name | e }}
+ {% endfor %}
+
\ No newline at end of file
diff --git a/app/templates/partials/cover.html b/app/templates/partials/cover.html
new file mode 100644
index 0000000000000000000000000000000000000000..5e93f23116404f97fa741965b7ae130670d8cee4
--- /dev/null
+++ b/app/templates/partials/cover.html
@@ -0,0 +1,4 @@
+{# Cover page partial #}
+
+
+
\ No newline at end of file
diff --git a/app/templates/partials/section.html b/app/templates/partials/section.html
new file mode 100644
index 0000000000000000000000000000000000000000..16a1f85db2bd3601d8b6a9c54ccf87666f55a82a
--- /dev/null
+++ b/app/templates/partials/section.html
@@ -0,0 +1,6 @@
+{# Generic section block partial — renders pre-built HTML from renderers.py #}
+
+ {{ rendered_html }}
+
\ No newline at end of file
diff --git a/app/templates/partials/toc.html b/app/templates/partials/toc.html
new file mode 100644
index 0000000000000000000000000000000000000000..a873f117f2e8cae098a4119d058e5b94b2e32f58
--- /dev/null
+++ b/app/templates/partials/toc.html
@@ -0,0 +1,17 @@
+{# Table of Contents — CSS dot-leader layout (single-line per entry) #}
+
+
CONTENTS
+
+ {% for e in toc_items_sorted %}
+ {% if e.title %}
+
\ No newline at end of file
diff --git a/app/templates/partials/university.html b/app/templates/partials/university.html
new file mode 100644
index 0000000000000000000000000000000000000000..398632771fda9619a78d6c4f705ac8f533d2ed3d
--- /dev/null
+++ b/app/templates/partials/university.html
@@ -0,0 +1,126 @@
+{# University section partial — iterates within handbook.html #}
+
+
+ {# ── University Title ── #}
+ {% if uni.website %}
+